package main

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"os"
	"strconv"
)

var DEBUG = true

// -----------------------------------------------------------------------------

// IO helper functions

// Returns next token from input.  It must be initialized by SetInput()
// before the first call.
var nextToken func() ([]byte, error)
var nextLine func() ([]byte, error)

// Holds a buffer for output.  It must be initialized by SetOutput().
// All IO functions (read*() and [e]print*()) should write to OutputWriter
// instead of this.
var OutputBuffer *bufio.Writer

// Holds an io.Writer.  It must be initialized by SetOutput()
var OutputWriter io.Writer

// Set IO functions for interactive input/output.
func SetInteractive(w io.Writer, r io.Reader) {
	SetUnbufferedInput(r)
	OutputBuffer = nil
	OutputWriter = w
}

// Setup OutputBuffer and OutputWriter.
func SetOutput(w io.Writer) {
	OutputBuffer = bufio.NewWriter(w)
	OutputWriter = OutputBuffer
}

// Flushes OutputBuffer
func Flush() {
	if OutputBuffer != nil {
		OutputBuffer.Flush()
	}
}

// Returns true if c is a white space
func IsSpace(c byte) bool {
	switch c {
	case '\t', '\n', '\v', '\f', '\r', ' ':
		return true
	}
	return false
}

func IsNewLine(c byte) bool {
	switch c {
	case '\n', '\r':
		return true
	}
	return false
}

// Setup nextToken with input buffer.
func SetInput(r io.Reader) {
	buf := new(bytes.Buffer)
	var b []byte

	var i int
	rest := func() ([]byte, error) {
		for i < len(b) && IsSpace(b[i]) {
			i++
		}
		if i == len(b) {
			return nil, io.ErrUnexpectedEOF
		}
		j := i
		for i < len(b) && !IsSpace(b[i]) {
			i++
		}
		return b[j:i], nil
	}
	initial := func() ([]byte, error) {
		io.Copy(buf, r)
		b = buf.Bytes()
		nextToken = rest
		return rest()
	}
	nextToken = initial

	restLn := func() ([]byte, error) {
		for i < len(b) && IsNewLine(b[i]) {
			i++
		}
		if i == len(b) {
			return nil, io.ErrUnexpectedEOF
		}
		j := i
		for i < len(b) && !IsNewLine(b[i]) {
			i++
		}
		return b[j:i], nil
	}

	initialLn := func() ([]byte, error) {
		io.Copy(buf, r)
		b = buf.Bytes()
		nextLine = restLn
		return restLn()
	}
	nextLine = initialLn
}

// Setup nextToken without input buffer.
func SetUnbufferedInput(r io.Reader) {
	buf := bufio.NewReader(r)
	var b []byte

	var i int
	nextToken = func() ([]byte, error) {
		var err error
		if i == len(b) {
			b, err = buf.ReadBytes('\n')
			if err != nil {
				return nil, err
			}
			i = 0
			j := len(b) - 1
			for 0 <= j && IsSpace(b[j]) {
				j--
			}
			b = b[0 : j+1]
		}
		for i < len(b) && IsSpace(b[i]) {
			i++
		}
		j := i
		for i < len(b) && !IsSpace(b[i]) {
			i++
		}
		if i == j {
			return nil, io.ErrUnexpectedEOF
		}
		return b[j:i], nil
	}
}

// -----------------------------------------------------------------------------

// IO functions

// Reads next token and return it as []byte
func readb() []byte {
	b, err := nextToken()
	if err != nil {
		panic(err)
	}
	return b[:len(b):len(b)]
}

// Reads next token and return it as string
func reads() string {
	return string(readb())
}

// Read next line as []byte.  Trailing '\n' will not be included.
// See also comments on readb()
func readbln() []byte {
	b, err := nextLine()
	if err != nil {
		panic(err)
	}
	return b[:len(b):len(b)]
}

// Read next line as string
func readsln() string {
	return string(readbln())
}

// Reads next token and return it as int64
func readll() int64 {
	i, err := strconv.ParseInt(reads(), 10, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

// Reads next token and return it as int
func readi() int {
	return int(readll())
}

// Reads next token and return it as float64
func readf() float64 {
	f, err := strconv.ParseFloat(reads(), 64)
	if err != nil {
		panic(err.Error())
	}
	return f
}

// Write args to OutputWriter with the format f
func printf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(OutputWriter, f, args...)
}

// Write args to OutputWriter without format
func println(args ...interface{}) (int, error) {
	return fmt.Fprintln(OutputWriter, args...)
}

// Write args to stderr with the format f
func eprintf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(os.Stderr, f, args...)
}

// Write args to stderr without format
func eprintln(args ...interface{}) (int, error) {
	return fmt.Fprintln(os.Stderr, args...)
}

func debugf(f string, args ...interface{}) {
	if !DEBUG {
		return
	}
	fmt.Fprintf(os.Stderr, f, args...)
}

func debug(args ...interface{}) {
	if !DEBUG {
		return
	}
	fmt.Fprintln(os.Stderr, args...)
}

// -----------------------------------------------------------------------------

// Utilities

func sumSlice(a []int) int {
	var res int
	for _, v := range a {
		res += v
	}
	return res
}

func sumSlicell(a []int64) int64 {
	var res int64
	for _, v := range a {
		res += v
	}
	return res
}

func readInts(N int) (int, []int) {
	if N == 0 {
		N = readi()
	}
	a := make([]int, N)
	for i := range a {
		a[i] = readi()
	}
	return N, a
}

func readIntsll(N int) (int, []int64) {
	if N == 0 {
		N = readi()
	}
	a := make([]int64, N)
	for i := range a {
		a[i] = readll()
	}
	return N, a
}

// -----------------------------------------------------------------------------

// Simple math functions

const (
	// big prime
	INF  = 1000000007
	INF2 = 1000000009
	INF3 = 998244353
)

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

func minll(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func minf(a, b float64) float64 {
	if a < b {
		return a
	}
	return b
}

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

func maxll(a, b int64) int64 {
	if a < b {
		return b
	}
	return a
}

func maxf(a, b float64) float64 {
	if a < b {
		return b
	}
	return a
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

func absll(a int64) int64 {
	if a < 0 {
		return -a
	}
	return a
}

func absf(a float64) float64 {
	if a < 0 {
		return -a
	}
	return a
}

// egcd(a, b) returns d, x, y:
//   d is gcd(a,b)
//   x, y are  integers that satisfy ax + by = d
func egcd(a, b int) (int, int, int) {
	if b == 0 {
		return a, 1, 0
	}
	d, x, y := egcd(b, a%b)
	return d, y, x - a/b*y
}

func egcdll(a, b int64) (int64, int64, int64) {
	if b == 0 {
		return a, 1, 0
	}
	d, x, y := egcdll(b, a%b)
	return d, y, x - a/b*y
}

func gcd(a, b int) int {
	d, _, _ := egcd(a, b)
	return d
}

func gcdll(a, b int64) int64 {
	d, _, _ := egcdll(a, b)
	return d
}

// set up IO functions
func init() {
	// for non-interactive
	SetInput(os.Stdin)
	SetOutput(os.Stdout)

	// Enable below when interactive.  Its ok to leave above intact.
	SetInteractive(os.Stdout, os.Stdin)
}

func main() {
	defer Flush()
	n := readi()
	_, a := readInts(n)
	answer := solve(n, a)
	println(answer)
}

func getNumber(n, i int, a []int) int {
	if i >= n {
		return a[i-n]
	}
	return a[i]
}

func solve(n int, a []int) int {
	cache := make([]int, n)
	for i := 0; i < n-1; i += 2 {
		cache[i/2] = gcd(a[i], a[i+1])
	}
	if n%2 == 1 {
		cache[n/2] = a[n-1]
	}

	maxGcdExcludeOneValue := 0
	for i := 0; i < n; i++ {
		tmp := gcd(getNumber(n, i+1, a), getNumber(n, i+2, a))
		for j := 0; j < n/2; j++ {
			if i/2 != j {
				tmp = gcd(tmp, cache[j])
			} else {
				if i%2 == 0 {
					tmp = gcd(tmp, a[i+1])
				} else {
					tmp = gcd(tmp, a[i-1])
				}
			}
		}
		maxGcdExcludeOneValue = max(tmp, maxGcdExcludeOneValue)
	}
	return maxGcdExcludeOneValue

	// maxGcdExcludeOneValue := 0
	// for i := 0; i < n; i++ {
	// 	tmp := gcd(getNumber(n, i+1, a), getNumber(n, i+2, a))
	// 	for j := 0; j < n; j++ {
	// 		if i != j {
	// 			tmp = gcd(tmp, getNumber(n, j, a))
	// 		}
	// 	}
	// 	maxGcdExcludeOneValue = max(maxGcdExcludeOneValue, tmp)
	// }
	// return maxGcdExcludeOneValue
}


MOD=10**9+7
cnt=0; sum=0; prev=nil; can=true; h=Hash.new(0)
def gs() gets.chomp end
def gi() gets.to_i end
def gsmi() gets.chomp.split.map(&:to_i) end

def desc(ar) ar.sort!{|x,y|y<=>x} end
def min(a,b) a<=b ? a : b end
def max(a,b) a>=b ? a : b end
def sum(ar) ar.inject(:+) end

def C(a,b) b==0||a==b ? 1 : (b=a-b if a/2<b;(a-b+1..a).inject(:*)/(1..b).inject(:*)) end

def puts_yesno(can) puts(can ? 'Yes' : 'No') end
def putsend(s) puts s; exit end
def debug(k,v) puts "#{k}:#{v}" end
########### ( ˘ω˘ )ｽﾔｧ… ###########
require 'prime'
def divisors(num)
  return [1] if num == 1

  pows = []
  # 0乗、1乗・・・した値を入れる
  num.prime_division.each do |b, r|
    pow = []
    0.upto(r).each do |n|
      pow << b ** n
    end

    pows << pow
  end

  first_array = pows.shift
  return first_array if pows.size == 0

  result = first_array.product(*pows)
  result.map do |item|
    item.inject { |sum, i| sum * i }
  end.sort
end

n=gi
a=gsmi

ans=1

# 最小2つの約数のどれかが答え
mins=a.min(2)
lcms = desc (divisors(mins[0])+divisors(mins[1])).uniq
lcms.each do |num|
  cnt=0
  a.each do |aa|
    next if aa%num==0
    cnt+=1
    break if cnt>1
  end
  if cnt<=1
    ans=num
    break
  end
end
puts ans


_,a=$<.map{|m|m.split.map(&:to_i)}
mgcd = a[0]
mngcd = 1
a[1..-1].each.with_index(1) do |ai, i|
  gcd = mgcd.gcd(a[i])
  mngcd = mngcd.gcd(a[i])
  if gcd < mgcd && mngcd < mgcd
    mngcd = mgcd
  end
  mgcd = gcd
end

fgcd = 0
a[1..-1].each do |ai|
  fgcd = fgcd.gcd(ai)
end
p [mngcd, mgcd, fgcd].max


N=gets.to_i
list=gets.chomp.split(" ").map(&:to_i)
list.sort!
list.reverse!
index=0
val=list[0]
if list.length==2
  print(list.max)
else

for i in 1..N-1
  if(val>val.gcd(list[i]))
    index=i
    val=val.gcd(list[i])
  end
end
if index==1
  if list[1].gcd(list[0])<list[1].gcd(list[2])
    index=0
  end
end
class Array
  def gcd
    self.inject{|a,b| a.gcd(b)}
  end
end
list.slice!(index)
print (list.gcd)

end


n=gets.to_i
s=gets.split.map &:to_i
a=s.reverse
ans=[]
ans1=[]
ans2=[]
ans1[0]=s[0]
ans2[0]=a[0]
sum1=s[0]
sum2=a[0]
for i in 1..n-2
  ans1 << sum1.gcd(s[i])
  ans2 << sum2.gcd(a[i])
end
ans << ans2[n-2]
ans << ans1[n-2]
ans2.delete_at(n-2)
ans1.delete_at(n-2)
ans2.reverse
for i in 0..n-3
  ans << ans1[i].gcd(ans2[i])
end
puts ans.max


n=gets.to_i
s=gets.split.map &:to_i
a=s.reverse
ans=[]
ans1=[]
ans2=[]
ans1[0]=s[0]
ans2[0]=a[0]
sum1=s[0]
sum2=a[0]
for i in 1..n-2
  ans1 << sum1.gcd(s[i])
  ans2 << sum2.gcd(a[i])
end
ans << ans2[n-2]
ans << ans1[n-2]
for i in 0..n-2
  ans << ans1[i].gcd(ans2[n-2-i])
end
puts ans.max


n=gets.to_i
s=gets.split.map &:to_i
a=s.reverse
ans=[]
ans1=[]
ans2=[]
ans1[0]=s[0]
ans2[0]=a[0]
sum1=s[0]
sum2=a[0]
for i in 1..n-2
  ans1 << sum1.gcd(s[i])
  ans2 << sum2.gcd(a[i])
end
ans << ans2[n-2]
ans << ans1[n-2]
for i in 0..n-2
  ans << ans1[i].gcd(ans2[n-1-i])
end
puts ans.max


use std::cmp::max;

fn read<T: std::str::FromStr>(
    stdin_lock: &mut std::io::StdinLock,
    buf: &mut Vec<u8>,
    delimiter: u8,
) -> T {
    buf.clear();
    let l = std::io::BufRead::read_until(stdin_lock, delimiter, buf).unwrap();
    buf.truncate(l - 1); // remove delimiter
    let s = unsafe { std::str::from_utf8_unchecked(&buf) };
    s.parse().unwrap_or_else(|_| panic!("read"))
}

fn gcd(a: i32, b: i32) -> i32 {
    fn gcd1(m: i32, n: i32) -> i32 {
        if n == 0 {
            m
        } else {
            gcd1(n, m % n)
        }
    }
    if a > b {
        gcd1(a, b)
    } else {
        gcd1(b, a)
    }
}

fn main() {
    let stdin = std::io::stdin();
    let mut stdin_lock = stdin.lock();
    let mut buf: Vec<u8> = Vec::new();
    let n: usize = read(&mut stdin_lock, &mut buf, b'\n');
    let mut av = vec![0i32; n];
    for i in 0..n - 1 {
        av[i] = read(&mut stdin_lock, &mut buf, b' ');
    }
    av[n - 1] = read(&mut stdin_lock, &mut buf, b'\n');

    let mut lv = vec![0i32; n];
    lv[0] = av[0];
    for i in 1..n {
        lv[i] = gcd(lv[i - 1], av[i]);
    }

    let mut rv = vec![0i32; n];
    rv[n - 1] = av[n - 1];
    for i in 1..n {
        let j = n - i - 1;
        rv[j] = gcd(rv[j + 1], av[j]);
    }

    let mut ans = max(lv[n - 2], rv[1]);
    for i in 1..n - 1 {
        ans = max(ans, gcd(lv[i - 1], rv[i + 1]));
    }
    println!("{}", ans);
}


use std::cmp::max;
fn read<T: std::str::FromStr>(
    stdin_lock: &mut std::io::StdinLock,
    buf: &mut Vec<u8>,
    delimiter: u8,
) -> T {
    buf.clear();
    let l = std::io::BufRead::read_until(stdin_lock, delimiter, buf).unwrap();
    buf.truncate(l - 1); // remove delimiter
    let s = unsafe { std::str::from_utf8_unchecked(&buf) };
    s.parse().unwrap_or_else(|_| panic!("read"))
}

fn gcd(a: i32, b: i32) -> i32 {
    fn gcd1(m: i32, n: i32) -> i32 {
        if n == 0 {
            m
        } else {
            gcd1(n, m % n)
        }
    }
    if a > b {
        gcd1(a, b)
    } else {
        gcd1(b, a)
    }
}

fn main() {
    let stdin = std::io::stdin();
    let mut stdin_lock = stdin.lock();
    let mut buf: Vec<u8> = Vec::new();
    let n: usize = read(&mut stdin_lock, &mut buf, b'\n');
    let mut av = vec![0i32; n];
    for i in 0..n - 1 {
        av[i] = read(&mut stdin_lock, &mut buf, b' ');
    }
    av[n - 1] = read(&mut stdin_lock, &mut buf, b'\n');

    let mut lv = vec![0i32; n];
    lv[0] = av[0];
    for i in 1..n {
        lv[i] = gcd(lv[i - 1], av[i]);
    }
    let mut rv = vec![0i32; n];
    rv[n - 1] = av[n - 1];
    for i in 1..n {
        let j = n - i - 1;
        rv[j] = gcd(rv[j + 1], av[j]);
    }

    let mut ans = max(gcd(av[1], rv[1]), gcd(lv[n - 2], av[n - 2]));
    for i in 1..n - 1 {
        ans = max(ans, gcd(lv[i - 1], rv[i + 1]));
    }
    println!("{}", ans);
}


use std::cmp;
use std::cmp::max;
use std::cmp::min;
use std::collections::HashMap;
use std::collections::HashSet;
use std::fmt;
use std::io::stdin;
use std::io::Error;
use std::io::ErrorKind;
use std::io::Read;

#[derive(Debug)]
struct Input {
    n: u32,
    a: HashMap<u32, u32>,
}

fn handle_input(input_str: String) -> Result<Input, Error> {
    let mut iter = input_str.split_whitespace();
    let n: u32 = iter.next().unwrap().parse().unwrap();
    let mut a = HashMap::new();
    for _ in 0..n {
        let v: u32 = iter.next().unwrap().parse().unwrap();
        let counter = a.entry(v).or_insert(0);
        *counter += 1;
    }
    let input = Input { n: n, a: a };
    Ok(input)
}

fn gcd(a: u32, b: u32) -> u32 {
    if a == 0 {
        return b;
    }
    gcd(b % a, a)
}

fn handle_output(input: Input) -> Result<String, Error> {
    let mut a = input.a.keys().clone();
    let first = *a.next().unwrap();
    let mut max_gcd = a.fold(first, |acc, &x| gcd(x, acc));
    for (&k, &v) in input.a.iter() {
        if v > 1 {
            continue;
        }
        let mut iter = input.a.keys().filter(|&&x| x != k);
        if let Some(&max) = iter.next() {
            let mut g = max;
            for &j in iter {
                g = gcd(j, g);
            }
            if g > max_gcd {
                max_gcd = g;
            }
        }
    }
    Ok(format!("{}", max_gcd))
}

fn main() {
    let mut input_str = String::new();
    let stdin = stdin();
    stdin.lock().read_to_string(&mut input_str).unwrap();
    let input = handle_input(input_str).unwrap();
    let output = handle_output(input).unwrap();
    println!("{}", output);
}


use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        n: usize,
        a: [usize; n]
    };

    let mut a: Vec<usize> = a;
    a.sort();

    let mut result = 1;
    let mut x = 1;

    let mut i = 1;
    while i <= a[1] {
        let c = a.iter().filter(|&x| x % i == 0).count();

        if c == n - 1 {
            result = i;
        } else if c == n && i != 1 {
            x *= i;
            a = a.iter().map(|x| x / i).collect();
        }

        i += 1;
    }

    if result == 1 {
        result = a[0];
    }

    println!("{}", result * x);
}


use proconio::input;

fn gcm(a: usize, b: usize) -> usize {
  if b == 0 {
    a
  } else {
    gcm(b, a % b)
  }
}

fn main() {
  input! {
    n: usize,
    mut vals: [usize;n]
  }

  if vals.len() == 2 {
    println!(
      "{}",
      if vals[0] < vals[1] {
        vals[1]
      } else {
        vals[0]
      }
    );
    return
  }

  vals.sort();
  let mut memo: Vec<usize> = vec![0;n];
  memo[n-1] = vals[n-1];
  let mut index = vals.len() - 2;
  loop {
    memo[index] = gcm(vals[index], memo[index+1]);
    if index == 0 { break }
    index -= 1;
  }

  let mut max = 1;
  let mut m = vals[0];
  for i in 1..n-1 {
    max = std::cmp::max(max, gcm(m, memo[i+1]));
    m = gcm(m, vals[i]);
  }
  max = std::cmp::max(max, gcm(vals[1], memo[2]));

  println!("{}", max);
}


use proconio::input;

fn gcm(a: usize, b: usize) -> usize {
  if b == 0 {
    a
  } else {
    gcm(b, a % b)
  }
}

fn main() {
  input! {
    n: usize,
    mut vals: [usize;n]
  }

  if vals.len() == 2 {
    println!(
      "{}",
      if vals[0] < vals[1] {
        vals[1]
      } else {
        vals[0]
      }
    );
    return
  }

  vals.sort();
  let mut memo: Vec<usize> = vec![0;n];
  memo[n-1] = vals[n-1];
  let mut index = vals.len() - 2;
  loop {
    memo[index] = gcm(vals[index], memo[index+1]);
    if index == 0 { break }
    index -= 1;
  }

  let mut max = 1;
  let mut m = vals[0];
  for i in 1..n-1 {
    max = std::cmp::max(max, gcm(m, memo[i+1]));
    m = gcm(m, vals[i]);
  }
  println!("{}", max);
}


func gcd(x: Int, _ y: Int) -> Int {
    return y>0 ? gcd(y, x%y) : x
}
let N = Int(readLine()!)!
let A = readLine()!.characters.split(" ").map{Int(String($0))!}
var L = [0]
var R = [0]
for i in 0..<N {
    L += [gcd(L[i], A[i])]
    R += [gcd(R[i], A[N-i-1])]
}
var ans = 0
for i in 0..<N {
    ans = max(ans, gcd(L[i], R[N-i-1]))
}
print(ans)


func gcd(x: Int, _ y: Int) -> Int {
    return y>0 ? gcd(y, x%y) : x
}
let N = Int(readLine()!)!
let A = readLine()!.characters.split(" ").map{Int(String($0))!}
var L = [0]
var R = [0]
for i in 0..<N {
    L += [gcd(L[i], A[i])]
    R += [gcd(R[i], A[N-i-1])]
}
print((0..<N).map{gcd(L[$0], R[N-$0-1])}.maxElement()!)


// 🐋💭
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readInt() -> Int {
    return Int(readLine()!)!
}

func readDoubles () -> [Double] {
    return readLine()!.split(separator: " ").map { Double($0)! }
}

func readDouble() -> Double{
    return Double(readLine()!)!
}

func readLines() -> [String] {
    return readLine()!.map { String($0) }
}
///最大公約数を返す
func gcd(_ m:Int, _ n:Int) -> Int {
    if n == 0 {return m}
    return gcd(n, m % n)
}

///最大公約数を返す
func gcd(_ array: [Int]) -> Int {
    var value = array[0]
    if array.count > 1 {
        for i in 1..<array.count {
            value = gcd(value, array[i])
        }
    }
    return value
}

///最小公倍数を返す
func lcm(_ m:Int, _ n:Int) -> Int {
    return m * n / gcd(m, n)
}

///素数判定(試し割り)
func isPrime(_ x:Int) -> Bool {
    if x <= 1 || x % 2 == 0 { return false }
    if x == 2 { return true }
    for i in stride(from: 3, to: Int(ceil(sqrt(Double(x)))), by: 2){
        if x % i == 0 {
            return false
        }
    }
    return true
}

//https://program-life.com/669
///実行速度の計測
func exectionTime(action: () -> Void) {
    let startDate = Date()
    action()
    let endDate = Date()
    print(endDate.timeIntervalSince(startDate))
}

//https://riptutorial.com/ja/swift/example/14738/インデックスを知らずに配列から要素を削除する
extension Array where Element: Equatable {

    mutating func remove(_ element: Element) {
        _ = firstIndex(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

func binarySearch(rifgt:Int, key:Int, ary:[String]) -> Int{
    var left = 0
    var right = rifgt

    while abs(right - left) > 1 {
        let mid = left + (right - left) / 2

        if Int(ary[mid])! < key {
            left = mid

        } else {
            right = mid
        }
    }
    return left
}

func arrangement (prev:String, ary:[String], returnVal:[String]) -> [String] {
    var returnVal = returnVal
    if ary.count == 0 {
        returnVal.append(prev)
        return returnVal
    }

    for s in ary {
        let wprev = prev + s
        var wary = ary
        wary.remove(s)
        returnVal = arrangement(prev: wprev, ary: wary, returnVal: returnVal)
    }
    return returnVal
}
// https://algo-logic.info/divisor/
/// 約数の配列を返す
func divisor(_ n:Int) -> [Int] {
    var ret = [Int]()
    var i = 1
    while i * i <= n {
        if n % i == 0 {
            ret.append(i)
            if i * i != n {
                ret.append(n / i)
            }
        }
        i += 1
    }
    return ret.sorted()
}

/// 1〜nまでの数字からなる辞書順列のm番目の順列を返す
func permutation(_ n: Int, _ m: Int) -> [Int] {
    var m = m

    var temp = [Int](repeating: 0, count: n)
    var surplus = [Int](repeating: 0, count: n)

    for i in 1...n {
        temp[i - 1] = i

        surplus[n - i] = m % i
        m = m / i
    }

    var order = [Int](repeating: 0, count: n)

    for i in 0..<n {
        order[i] = temp[surplus[i]]
        var j = surplus[i]
        while j + 1 < n {
            temp[j] = temp[j + 1]
            j += 1
        }
    }
    return order
}
func check(_ ary: [Int], _ n: Int) -> Bool {
    for i in 0..<ary.count {
        if ary[i] == n { return true }
    }
    return false
}

func main() {
    let N = readInt()
    let A = readInts()
    //＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿ここまで入力
    var ma = 0
    for i in 1..<N {
        var Ad = A
        Ad[i - 1] = Ad[i]
        ma = max(ma, gcd(Ad))
    }
    print(ma)
}
main()


func gcd(x: Int, _ y: Int) -> Int {
    return y>0 ? gcd(y, x%y) : x
}
let N = Int(readLine()!)!
let A = readLine()!.characters.split(" ").map{Int(String($0))!}
var L = [0]
var R = [0]
for i in 0..<N {
    L += [gcd(L[i], A[i])]
    R += [gcd(R[i], A[N-i-1])]
}
print((0..<N).map{gcd(L[i], R[N-i-1])}.maxElement()!)


let N = Int(readLine()!)!
let A = readLine()!.characters.split(" ").map{Int(String($0))!}
var L = [0]
var R = [0]
for i in 0..<N {
    L += [gcd(L[i], A[i])]
    R += [gcd(R[i], A[N-i-1])]
}
var ans = 0
for i in 0..<N {
    ans = max(ans, gcd(L[i], R[N-i-1]))
}
print(ans)


function main(input) {
  input = input.trim().split("\n");
  const n = Number(input[0]);
  const a = input[1].split(" ").map(n => Number(n));
  const gcd = (a, b) => {
    if (b === 0) return a;
    return gcd(b, a%b);
  }
  const l = [];
  for (let i = 0; i < n; i++) {
    if (i === 0) {
      l.push(a[i]);
      continue;
    }
    l.push(gcd(l[l.length-1], a[i]));
  }

  const r = [];
  for (let i = n - 1; 0 <= i; i--) {
    if (i === n-1) {
      r.push(a[i]);
      continue;
    }
    r.push(gcd(r[r.length-1], a[i]));
  }

  let result = 0;
  for (let i = 0; i < n; i++) {
    const num = gcd(i === 0 ? 0 : l[i-1], i === n-1 ? 0 : r[n-i-2]);
    if (result < num) result = num;
  }
  console.log(result);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));


{
  const main = (input: string): void | string | number => {
    const re = reader(input)
    const N = re.n()
    const a = re.ns()

    // gcd of 0~i
    const l: number[] = []
    const r: number[] = []

    l[0] = a[0]
    r[N - 1] = a[N - 1]

    for (let i = 1; i < N; i++) {
      l[i] = _gcd(l[i - 1], a[i])
    }
    for (let i = N - 2; i >= 0; i--) {
      r[i] = _gcd(r[i + 1], a[i])
    }

    // console.log(l)
    // console.log(r)

    let ans = 0

    for (let i = -2; i < N; i++) {
      // console.log(l[i] || r[i + 2], r[i + 2] || l[i])
      ans = Math.max(ans, _gcd(l[i] || r[i + 2], r[i + 2] || l[i]))
    }
    // Object.keys(lib).map(k => {
    //   const v = lib[k]

    //   if (v >= N - 1) {
    //     ans = Math.max(ans, Number(k))
    //   }
    // })
    return ans
  }

  const reader = (str: string) => {
    const lines = str.trim().split('\n')
    const s = () => lines.shift() || ''
    const n = () => Number(s())

    const ss = () => s().split(' ')
    const ns = () => ss().map(Number)
    const nls = () => lines.map(Number)

    return { lines, s, n, ss, ns, nls }
  }

  const _gcd = (a, b) => (b ? _gcd(b, a % b) : a)

  const getInput = () => require('fs').readFileSync('/dev/stdin', 'utf8')
  const res = main(getInput())

  if (typeof res === 'number' || typeof res == 'string') console.log(res)
}


import * as fs from 'fs';

function Picker(input) {
  var lines = input.split('\n');
  var fields = lines.reduce(function(all, line) { return all.concat(line.split(' ')); }, []);
  var p = 0;

  return {
    int: function() {
      return parseInt(fields[p++], 10);
    },
    float: function() {
      return parseFloat(fields[p++]);
    },
    str: function() {
      return fields[p++];
    }
  };
}

const input = fs.readFileSync("/dev/stdin", "utf8");
const pick = Picker(input);

//////////////////////////////////////////

function gcd(a, b) {
  if (b === 0) {
    return a;
  }
  return gcd(b, a % b);
}

const n = pick.int();
const a = new Array(n).fill(0).map(() => pick.int());

const l = [0];
for (let i = 0; i < n; ++i) {
  l.push(gcd(l[i], a[i]));
}
const r = [0];
for (let i = 0; i < n; ++i) {
  r.push(gcd(r[i], a[n - i - 1]));
}

let max = 0;
for (let i = 0; i < n; ++i) {
  const v = gcd(l[i], r[n - i - 1]);
  if (v > max) max = v;
}

console.log(max);


{
  const main = (input: string): void | string | number => {
    const r = reader(input)
    const N = r.n()
    const A = r.ns()

    // const lib: number[] = []
    const lib: Record<number, number> = {}

    A.forEach(a => {
      const { list } = _divisors(a)

      list.forEach(div => {
        lib[div] = (lib[div] || 0) + 1
      })
    })

    // console.log(lib)

    let ans = 0

    Object.keys(lib).map(k => {
      const v = lib[k]

      if (v >= N - 1) {
        ans = Math.max(ans, Number(k))
      }
    })
    return ans
  }

  const reader = (str: string) => {
    const lines = str.trim().split('\n')
    const s = () => lines.shift() || ''
    const n = () => Number(s())

    const ss = () => s().split(' ')
    const ns = () => ss().map(Number)
    const nls = () => lines.map(Number)

    return { lines, s, n, ss, ns, nls }
  }
  const _divisors = (n: number) => {
    const sq = Math.floor(Math.sqrt(n))
    const list: number[] = []
    const pairs: [number, number][] = []

    for (let i = sq; i > 0; i--) {
      if (n % i !== 0) {
        continue
      }
      list.unshift(i)
      if (sq * sq !== n) {
        list.push(n / i)
      }
      pairs.unshift([i, n / i])
    }
    return { list, pairs }
  }

  const getInput = () => require('fs').readFileSync('/dev/stdin', 'utf8')
  const res = main(getInput())

  if (typeof res === 'number' || typeof res == 'string') console.log(res)
}


const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{const t=[...ar];return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{const t=[...ar];return t.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a:any[]):any[]=>{return Array.from(new Set(a))};const gcd=(x,y)=>{while(y){[x,y]=[y,x%y]}return x};
const main=()=>{
  let n=tn(),ns=tnn(n)
  if(n==2){
    to(gcd(ns[0],ns[1]))
    return
  }
  if(n==3){
    to(max(gcd(ns[0],ns[1]),gcd(ns[1],ns[2]),gcd(ns[0],ns[2])))
    return
  }
  let calc=max(gcd(ns[0],ns[1]),gcd(ns[2],ns[3])),saveIndex
  for(let i=0;i<n;i++){
    if(calc>gcd(calc,ns[i])){
      calc=gcd(calc,ns[i])
      saveIndex = i
    }
  }
  calc=max(gcd(ns[0],ns[1]),gcd(ns[2],ns[3])),saveIndex
  for(let i=0;i<n;i++){
    if(saveIndex==i)continue
    calc=gcd(calc,ns[i])
  }
  to(calc)
}
main()


const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{const t=[...ar];return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{const t=[...ar];return t.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a:any[]):any[]=>{return Array.from(new Set(a))};const rep=(n,c:(i?:number)=>void)=>{for(let i=0;i<n;i++)c(i)};const gcd=(x,y)=>{while(y){[x,y]=[y,x%y]}return x};
const main=()=>{
  let n=tn(),ns=tnn(n)
  if(n==2){
    to(gcd(ns[0],ns[1]))
    return
  }
  let calc=max(gcd(ns[0],ns[1]),gcd(ns[1],ns[2]),gcd(ns[0],ns[2])),saveIndex
  for(let i=0;i<n;i++){
    if(calc>gcd(calc,ns[i])){
      calc=gcd(calc,ns[i])
      saveIndex = i
    }
  }
  calc=max(gcd(ns[0],ns[1]),gcd(ns[1],ns[2]),gcd(ns[0],ns[2]))
  for(let i=0;i<n;i++){
    if(saveIndex==i)continue
    calc=gcd(calc,ns[i])
  }
  to(calc)
}
main()


input_str = input().split(" ")
input_int = list(map(int, input_str))
A = input_int[0]
B = input_int[1]
T = input_int[2]

bis_sum = 0
start = 0
end = A
while True:
    if start < T+0.5 and end > T+0.5:
        break
    start += A
    end += A
    bis_sum += B

print(bis_sum)


lst = input().split()
A = int(lst[0])
B = int(lst[1])
T = int(lst[2])

print((T//A)*B)


a,b,t=map(int,input().split())
print(t//a*b)


N = int(input())
A = list(map(int, input().split()))

souwa = 0
cnt = 0
keep = 1e10

for i in range(N):
    if A[i] < 0:
        cnt += 1
        A[i] *= (-1)

    souwa += A[i]
    keep = min(keep, A[i])

print(souwa - 2 * keep * (cnt % 2))


a, b, t = map(int, input().split())
print(t//a*b)
debug_pri


A, B, T = map(int, input().split())

print((T+0.5)//A*B)


import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

public class Main {

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int A = sc.nextInt();
		int B = sc.nextInt();
		int T = sc.nextInt();
		System.out.println(B * (T / A));
	}
}

class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        }else{
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }
    private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
    private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
    public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
    public String next() {
        if (!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while(isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    public long nextLong() {
        if (!hasNext()) throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while(true){
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            }else if(b == -1 || !isPrintableChar(b)){
                return minus ? -n : n;
            }else{
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
    public int nextInt() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
        return (int) nl;
    }
    public double nextDouble() { return Double.parseDouble(next());}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.List;

class Main {

    public static void main(String[] args) throws Exception {

        try {

            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

            List<String> input = Arrays.asList(br.readLine().split(" "));

            int A = Integer.parseInt(input.get(0));
            int B = Integer.parseInt(input.get(1));
            int T = Integer.parseInt(input.get(2));

            int result = 0;
            while (T >= A) {
                result += B;
                T -= A;
            }

            System.out.println(result);
        } catch (IOException | NumberFormatException e) {
            e.printStackTrace();
            System.exit(0);
        } catch (final Exception e) {
            e.printStackTrace();
            System.exit(0);
        }
    }
}


import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;

public class Main {

	public static void main(String[] args) throws IOException {
		new Main().solve();
	}

	private void solve() throws IOException {
		try {
			solveA();
			//			 solveB();
			//			 solveC();
			//			 solveD();
			//			 solveE();
			//			 solveF();
		} finally {
			if (in != null) {
				in.close();
			}
			if (out != null) {
				out.flush();
				out.close();
			}
		}

	}

	private void solveA() {
		int a = nextInt();
		int b = nextInt();
		int t = nextInt();

		int res = 0;

		double time = 0;
		while (time <= t + 0.5) {
			time += a;
			if (time <= t + 0.5) {
				res += b;
			}
		}

		out.println(res);
	}

	private void solveB() {
		int numN = nextInt();

		out.println("");
	}

	private void solveC() {
		int numN = nextInt();

		out.println("");
	}

	private void solveD() {
		int numN = nextInt();

		out.println("");
	}

	private void solveE() {
		int numN = nextInt();

		out.println("");
	}

	private void solveF() {
		int numN = nextInt();

		out.println("");
	}

	private final PrintWriter out = new PrintWriter(System.out);
	private final InputStream in = System.in;
	private final byte[] buffer = new byte[1024];
	private int ptr = 0;
	private int buflen = 0;

	private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	}

	private int readByte() {
		if (hasNextByte())
			return buffer[ptr++];
		else
			return -1;
	}

	private static boolean isPrintableChar(int c) {
		return 33 <= c && c <= 126;
	}

	private void skipUnprintable() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
	}

	public boolean hasNext() {
		skipUnprintable();
		return hasNextByte();
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	public String next() {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public long nextLong() {
		if (!hasNext())
			throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}
}


package com.example.demo.service;

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt(), b = sc.nextInt(), t = sc.nextInt(), ans = 0;
        for(int i=1;i<t+1;i++)if(i%a==0)ans+=b;
        System.out.println(ans);
    }
}


import java.util.*;

/**
 * Main
 */
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// 整数の入力
		int A = sc.nextInt();
		int B = sc.nextInt();
		int T = sc.nextInt();
		int Bis = 0;
		int Time = 0;
		while (Time < T + 0.5) {
			Bis += B;
			Time += A;
		}

		System.out.println(Bis);

		sc.close();
	}
};


import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		Double A = sc.nextDouble();
		Double B = sc.nextDouble();
		Double T = sc.nextDouble();
		sc.close();
		int a = (int)((T+0.5)/A);
		System.out.println(a*B);
	}

}


#include <iostream>
using namespace std;

int main() {
	int a, b, t;
	cin >> a >> b >> t;

	cout << (t / a) * b << endl;

	//system("pause");
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define all(v) v.begin(), v.end()
#define mod 1000000007
//'A' = 65, 'Z' = 90, 'a' = 97, 'z' = 122

int main() {
    int a, b, t;
    cin >> a >> b >> t;
    cout << b  * (t / a) << endl;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

int main(void){
    int A, B, T;
    cin >> A >> B >> T;
    cout << (T / A) * B << endl;

    return 0;
}


#pragma GCC optimize("O3")

#define _GLIBCXX_DEBUG
#include <iostream>
#include <vector>
#include <string>
#include <string_view>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
using namespace std;

/*----------macros----------*/

//input, output================
#define fastio                          \
std::ios::sync_with_stdio(false);       \
std::cin.tie(nullptr);                  \
std::cout.tie(nullptr)

#define endl '\n'
#define fcout(a)                        \
cout << fixed << setprecision((int)(a))

//typedef===============
typedef long long       ll;
typedef long double     ld;
typedef vector<int>     Vi;
typedef vector<ll>      Vl;
typedef pair<int, int>  Pii;
typedef pair<ll, ll>    Pll;

//const number==========
constexpr ll INF    = (ll)1e9 + 1;
constexpr ll INFll  = (ll)1e18 + 1;
constexpr ll MOD1   = 1000000007;
constexpr ll MOD2   = 998244353;
constexpr ld PI     = 3.141592653589793L;

//member================
#define psb push_back
#define epb emplace_back
#define psf push_front
#define mkp make_pair
#define fst first
#define snd second

//others================
#define sz(x)                           \
(int) x.size()

#define all(x)                          \
(x).begin(), (x).end()

#define rall(x)                         \
(x).rbegin(), (x).rend()

#define rep(i, n)                       \
for(int i = 0; (i) < (n); ++(i))

#define reps(i, n)                      \
for(int i = 1; (i) <= (n); ++(i))

#define rrep(i, n)                      \
for(int i = n - 1; (i) >= 0 ; --(i))

#define repbit(bit, n)                  \
for(int bit = 0; (bit) < (1 << (n)); ++(bit))

#define ifbit(bit, i)                   \
if((bit) & (1 << (i)))

#define CtoI(c)                         \
int((c)) - int('0')

#define ItoC(c)                         \
char((c) + '0')

//functions=============
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b)
{ return a < b && (a = b, true); }

template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b)
{ return a > b && (a = b, true); }

// Vi  dx = {1, 0, -1, 0},
//     dy = {0, 1, 0, -1};

// Vi  dx2 = { 1,1,0,-1,-1,-1,0,1 },
//     dy2 = { 0,1,1,1,0,-1,-1,-1 };

/*--------additional--------*/

/*----------main------------*/

int main() {
fastio;

    int a, b, t; cin >> a >> b >> t;

    int i = 1;
    int cnt = 0;
    while(t > 0){
        ++cnt;
        t -= a * i;
        ++i;
    }

    cout << b * cnt << endl;

return 0;
}


#include<iostream>
#include<string>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<algorithm>
#include<utility>
#include<map>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
const int INF = 1001001001;

ll pow_mod(ll p, ll n, ll m) {
	if (n == 0) return 1;
	else if (n == 1) return p % m;
	else if (n % 2 == 1) return p * pow_mod(p, n - 1, m) % m;
	else {
		ll tmp = pow_mod(p, n / 2, m);
		return (tmp * tmp) % m;
	}
}

ll gcd(ll x, ll y) {
	if (y == 0) {
		return x;
	}
	return gcd(y, x % y);
}

ll com_mod(ll n, ll k, ll m) {
	if (k == 0) return 1;
	else {
		ll x = 1;
		ll y = 1;
		for (ll i = 0; i < k; i++) {
			x = (x * (n - i)) % m;
			y = (y * (i + 1)) % m;
		}
		ll res = (x * pow_mod(y, m - 2, m)) % m;
		return res;
	}
}

int main() {
	int a, b, t; cin >> a >> b >> t;
	cout << (t + 0.5) / a * b << endl;
	return 0;
}


#include <iostream>
using namespace std;

int main() {
  int N, X_Y;
  cin >> N;

  int V[N], C[N];
  for(int i=0; i<N; i++) {
    cin >> V[i];
  }

  for(int i=0; i<N; i++) {
    cin >> C[i];
  }

  X_Y = 0;
  for(int i=0; i<N; i++) {
    if(V[i] > C[i]) {
      X_Y = X_Y + (V[i] - C[i]);
    }
  }

  cout << X_Y << endl;
  return 0;
}


#include <stdio.h>
#include <sysexits.h>
#include <math.h>
int main(void){
  int a,b,T,sum;
  if(scanf("%d %d %d",&a,&b,&T)!=3){
exit(1);
}

  sum = (T/a)*b;
  printf("%d",sum);
  return 0;
}


#include<stdio.h>

int main()
{
	int A,B,T;

	scanf("%d%d%d",&A,&B,&T);
	int number;

	number=B*(T/A);
	printf("%d",number);

}


#include<stdio.h>

int main(){
	int a,b,t,A;
	scanf("%d %d %d",&a,&b,&t);
	A=(int)(t/a)*b;
	printf("%d\n",A);
	return 0;
}


#include<stdio.h>

int main(void){
  int a,b,t;
  scanf("%d %d %d",&a,&b,&t);
  int s=1,k=0;

  for(int i=0;(double)i<(double)t+0.5;i++){
    if(i=s*a){
      s++;
      k+=b;
    }
  }
  printf("%d\n",k);
return 0;
}


#include<stdio.h>

int main(void){
  int a,b,t;
  scanf("%d %d %d",&a,&b,&t);
  int s=1,k=0;

  for(int i=0;i<t+0.5;i++){
    if(i=s*a){
      s++;
      k+=b;
    }
  }
  printf("%d",k);
return 0;
}


#include <stdio.h>
int main(void)
{
    int A,B,T;
    scanf("%d %d",&A,&B,&T);
    printf("%d",(T/A)*B);
}


function Main(input) {
    "use strict";
    const els = input.split(' ');
    let i = parseInt(els[0],10);
    let sum = 0;

    while(i <= els[2]){
        sum += parseInt(els[1],10);
        i += parseInt(els[0],10);
    }
    console.log(sum);
}

Main(require('fs').readFileSync('/dev/stdin', 'utf-8'));


// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split(" ");
	//文字列から10進数に変換するときはparseIntを使います
	var a = parseInt(input[0], 10);
	var b = parseInt(input[1], 10);
	var t = parseInt(input[2], 10);

  	var sum = 0;
  	for (var i = a; i < t + 0.5; i += a) {
      sum += b;
    }
	//出力
	console.log(sum);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


//$ node 181222B.js < 181222B.txt
function Main(input) {
  input = input.split('\n') // 1行目がinput[0], 2行目がinput[1], …に入る
  for(var i=0;i<input.length;i++){
    var tmp = input[i].split(' ')
    input[i] = []
    for(var ii=0;ii<tmp.length;ii++){
      input[i].push(tmp[ii])
    }
  }
  input = input[0]
  var ans = 0
  var i = 0
  var sec = 0
  while(sec<input[2]*1){
    sec++
    i++
    if(i==input[0]*1){
      ans += input[1]*1
      i=0
    }
  }
  console.log(ans)
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));


var fs = require('fs');

var inputs = fs.readFileSync('/dev/stdin', 'utf8').split('\n');
var num = Number(inputs[0]);
var vnums = inputs[1].split(' ').map(function (i) {return Number(i);});
var cnums = inputs[2].split(' ').map(function (i) {return Number(i);});
var max = null;
for (var i = 0; i < num; i++) {
  for (var k = i + 1; k < num; k++) {
    var cost = vnums[i] - cnums[i];
    for (var j = k; j < num; j++) {
      cost += vnums[j] - cnums[j];
      if (max === null || max < cost) {
        max = cost;
      }
    }
  }
}
console.log(max);


function Main(input) {
  input = input.split(' ');
  let A = parseInt(input.shift());
  let B = parseInt(input.shift());
  let T = parseInt(input.shift());
  console.log(Math.floor(T/A) * B)
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


<html>
<body>
<script>
var x=prompt(),y=prompt(),z=prompt();
document.write(x/y*z);
</script>
</body>
</html>


package main

import (
	"fmt"
)

func main(){
	var A, B, K int
	qtd := 0
	fmt.Scanf("%d %d %d", &A, &B, &K)
	if A > K {
		fmt.Println(0)
		return
	}
	for i:=1; i<=K; i++ {
		if i%A == 0 {
			qtd += B
		}
	}
	fmt.Println(qtd)
}


package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"reflect"
	"sort"
	"strconv"
	"strings"
	// "regexp"
)

/* sort */
type pair struct {
	index  int64
	p1, p2 interface{}
}
type pairs []pair

func (slice pairs) Len() int {
	return len(slice)
}

func (slice pairs) Less(i, j int) bool {
	return slice[i].index < slice[j].index
}

func (slice pairs) Swap(i, j int) {
	slice[i], slice[j] = slice[j], slice[i]
}

/* sort */
type Int64Slice []int64

func (slice Int64Slice) Len() int {
	return len(slice)
}

func (slice Int64Slice) Less(i, j int) bool {
	return slice[i] < slice[j]
}

func (slice Int64Slice) Swap(i, j int) {
	slice[i], slice[j] = slice[j], slice[i]
}
func Int64s(a []int64)                    { sort.Sort(Int64Slice(a)) }
func Int64sSliceAreSorted(a []int64) bool { return sort.IsSorted(Int64Slice(a)) }

const (
	initialBufSize = 1e4
	maxBufSize     = 1e8
	INF            = 1e8
)

var (
	scanner = bufio.NewScanner(os.Stdin)
	writer  = bufio.NewWriter(os.Stdout)
	di      = []int64{-1, 0, 1, 0}
	dj      = []int64{0, -1, 0, 1}
)

func main() {
	buf := make([]byte, initialBufSize)
	scanner.Buffer(buf, maxBufSize)
	scanner.Split(bufio.ScanWords)
	A, B, T := readInt(), readInt(), readInt()
	fmt.Println((T / A) * B)
}

/*==========================================
 *             Library
 *==========================================*/
func NextPermutation(x sort.Interface) bool {
	n := x.Len() - 1
	if n < 1 {
		return false
	}
	j := n - 1
	for ; !x.Less(j, j+1); j-- {
		if j == 0 {
			return false
		}
	}
	l := n
	for !x.Less(j, l) {
		l--
	}
	x.Swap(j, l)
	for k, l := j+1, n; k < l; {
		x.Swap(k, l)
		k++
		l--
	}
	return true
}
func doubleAry(h int64, w int64, init int64) (res [][]int64) {
	res = make([][]int64, h)
	for i := int64(0); i < h; i++ {
		res[i] = make([]int64, w)
		for j := int64(0); j < w; j++ {
			res[i][j] = init
		}
	}
	return
}

func aryEq(a []int64, b []int64) bool {
	return reflect.DeepEqual(a, b)
}

func clone(n []int64) (r []int64) {
	r = make([]int64, len(n))
	for i := 0; i < len(n); i++ {
		r[i] = n[i]
	}
	return
}
func write(s string) {
	writer.WriteString(s)
}

func print() {
	writer.Flush()
}

// scanner.Split(bufio.ScanWords) をコメントアウトしないと使用不可
func readLine() (s string) {
	if scanner.Scan() {
		s = scanner.Text()
	}
	return s
}

func readInt() (read int64) {
	scanner.Scan()
	read, err := strconv.ParseInt(scanner.Text(), 10, 64)
	if err != nil {
		panic(err)
	}
	return
}

func readFloat() (read float64) {
	scanner.Scan()
	read, err := strconv.ParseFloat(scanner.Text(), 64)
	if err != nil {
		panic(err)
	}
	return
}

func readRunes() (read []rune) {
	scanner.Scan()
	for _, v := range scanner.Text() {
		read = append(read, v)
	}
	return
}

func readString() (read string) {
	scanner.Scan()
	read = scanner.Text()
	return
}

func readStrings() (read []string) {
	scanner.Scan()
	for _, v := range scanner.Text() {
		read = append(read, string(v))
	}
	return
}

func s2i(s string) int64 {
	var intVal, e = strconv.ParseInt(s, 10, 64)
	if e != nil {
		panic(e)
	}
	return intVal
}

func i2s(i int64) string {
	var strVal = strconv.FormatInt(i, 10)
	return strVal
}

func s2f(s string) float64 {
	var floatVal, e = strconv.ParseFloat(s, 64)
	if e != nil {
		panic(e)
	}
	return floatVal
}

func abs(i int64) int64 {
	return int64(math.Abs(float64(i)))
}

func sum(i []int64) int64 {
	sum := int64(0)
	for _, val := range i {
		sum += val
	}
	return sum
}

func split(s string) []string {
	return strings.Fields(s)
}

func strAry2intAry(strs []string) []int64 {
	var ret = make([]int64, 0, len(strs))
	for _, str := range strs {
		var intVal = s2i(str)
		ret = append(ret, intVal)
	}
	return ret
}

func intAry2strAry(nums []int64) []string {
	var ret = make([]string, 0, len(nums))
	for _, num := range nums {
		var strVal = i2s(num)
		ret = append(ret, strVal)
	}
	return ret
}

func ary2str(strs []string) string {
	return strings.Join(strs, " ")
}

func reverse(res []int64) []int64 {
	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
		res[i], res[j] = res[j], res[i]
	}
	return res
}
func reverseStr(res []string) []string {
	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
		res[i], res[j] = res[j], res[i]
	}
	return res
}

func ini(res []int, init int) {
	if len(res) == 0 {
		return
	}
	res[0] = init
	for i := 0; i < len(res); i++ {
		copy(res[i:], res[:i])
	}
}

//
// func regexpExample() {
//     // Your code here!
//     var str = "13:20"
//     r := regexp.MustCompile(`(\d+):(\d+)`)
//     fmt.Println(r.FindStringSubmatch(str))
// }

// type Country struct {
//     gold int
//     silver int
//     blonze int
// }

// // 複数ソートのサンプル
// func stableSortExample() []Country{
//     var country = []Country {
//         {gold:1, silver:2, blonze:3},
//         {gold:1, silver:2, blonze:3},
//         {gold:1, silver:3, blonze:2},
//         {gold:1, silver:3, blonze:3},
//     }
//     sort.SliceStable(country, func(i, j int) bool { return country[i].blonze > country[j].blonze })
//     sort.SliceStable(country, func(i, j int) bool { return country[i].silver > country[j].silver })
//     sort.SliceStable(country, func(i, j int) bool { return country[i].gold > country[j].gold })
//     return country
// }


package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"math"
	"os"
	"strconv"
)

const (
	initialBufSize = 10000
	maxBufSize     = 1000000
	mod            = 1e9 + 7
)

var (
	sc *bufio.Scanner = func() *bufio.Scanner {
		sc := bufio.NewScanner(os.Stdin)
		buf := make([]byte, initialBufSize)
		sc.Buffer(buf, maxBufSize)
		sc.Split(bufio.ScanWords)
		return sc
	}()
)

func main() {
	A := getInt()
	B := getInt()
	T := getInt()

	fmt.Println(T/A * B)
}

type Graph struct {
	n     int
	edges [][]int
}

func NewGraph(n int) *Graph {
	g := &Graph{
		n:     n,
		edges: make([][]int, n),
	}
	return g
}

func (g *Graph) AddEdge(u, v int) {
	g.edges[v] = append(g.edges[v], u)
	g.edges[u] = append(g.edges[u], v)
}

func dfs(c int, edges [][]int, visited map[int]struct{}) {
	visited[c] = struct{}{}

	for _, v := range edges[c] {
		_, flag := visited[v]
		if flag {
			continue
		}
		dfs(v, edges, visited)
	}
}

func bfs(c int, graph *Graph) {
	next := make([]int, 0)
	next = append(next, c)
	visited := make(map[int]struct{})

	for ; len(next) != 0; {
		u := next[0]
		next = next[1:]
		visited[u] = struct{}{}

		for _, v := range graph.edges[u] {
			_, flag := visited[v]
			if flag {
				continue
			}

			// なにか処理

			next = append(next, v)
		}
	}
}

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

func getIntArray(n int) []int {
	array := make([]int, n)
	for i := 0; i < n; i++ {
		array[i] = getInt()
	}
	return array
}

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

func abs(a int) int {
	return int(math.Abs(float64(a)))
}

func pow(p, q int) int {
	return int(math.Pow(float64(p), float64(q)))
}

func powMod(n, p int) int {
	if p == 0 {
		return 1
	} else if p%2 == 0 {
		t := powMod(n, p/2)
		return calcMod(t * t)
	} else {
		return calcMod(n * powMod(n, p-1))
	}
}

func min(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton min() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Min(float64(res), float64(nums[i])))
	}
	return res
}

func max(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton max() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Max(float64(res), float64(nums[i])))
	}
	return res
}

func strSearch(a []string, b string) bool {
	for i := 0; i < len(a); i++ {
		if a[i] == b {
			return true
		}
	}
	return false
}

func printIntArray(array []int) {
	strArray := fmt.Sprint(array)
	fmt.Println(strArray[1 : len(strArray)-1])
}

func calcMod(x int) int {
	return x % mod
}

func reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func isPrime(n int) bool {
	if n < 2 {
		return false
	} else if n == 2 {
		return true
	} else if n % 2 == 0 {
		return false
	}

	sqrtN := int(math.Sqrt(float64(n)))
	for i := 3; i <= sqrtN; i += 2 {
		if n % i == 0 {
			return false
		}
	}

	return true
}

func contains(s []int, e int) bool {
	for _, v := range s {
		if e == v {
			return true
		}
	}
	return false
}

func makeRange(min, max int) []int {
	a := make([]int, max-min+1)
	for i := range a {
		a[i] = min + i
	}
	return a
}

func powerset2(nums []int) [][]int {
	length := int(math.Pow(2, float64(len(nums))))
	result := make([][]int, length)

	index := 0
	result[index] = []int{}
	index++

	for _, n := range nums {
		max := index
		for i := 0; i < max; i++ {
			result[index] = copyAndAppend(result[i], n)
			index++
		}
	}

	return result
}

func copyAndAppend(nums []int, n int) []int {
	dst := make([]int, len(nums)+1)
	copy(dst, nums)
	dst[len(nums)] = n
	return dst
}

func calcGcd(x, y int) int {
	if y == 0 {
		return x
	} else if x >= y {
		return calcGcd(y, x % y)
	} else {
		return calcGcd(x, y % x)
	}
}

func getDivisor(n int) []int {
	var divisor []int
	divisor = append(divisor, 1)
	if n != 1 {
		divisor = append(divisor, n)
	}

	sqrt := int(math.Sqrt(float64(n)))
	for i := 2; i <= sqrt; i++ {
		if n % i == 0 {
			divisor = append(divisor, i)
			divisor = append(divisor, n/i)
		}
	}
	return divisor
}

type intHeap []int

func (h intHeap) Len() int {
	return len(h)
}

func (h intHeap) Less(i, j int) bool {
	return h[i] > h[j]
}

func (h intHeap) Swap(i, j int) {
	h[i], h[j] = h[j], h[i]
}

func (h *intHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}

func (h *intHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func initHeap() *intHeap {
	ih := &intHeap{}
	heap.Init(ih)
	return ih
}

func (h *intHeap) pushHeap(n int) {
	heap.Push(h, n)
}

func (h *intHeap) popHeap() int {
	return heap.Pop(h).(int)
}

func factMod(n int) int {
	value := 1
	for ; n > 1; n-- {
		value = calcMod(value * n)
	}
	return value
}

func combinationMod(n, k int) int {
	factN := factMod(n)
	factK := factMod(k)
	factNK := factMod(n - k)
	factKR := powMod(factK, mod - 2)
	factNKR := powMod(factNK, mod - 2)
	return calcMod(factN * calcMod(factKR * factNKR))
}


package main

import (
	"bufio"
	"fmt"
	"os"
)

var (
	read  = bufio.NewReader(os.Stdin)
	write = bufio.NewWriter(os.Stdout)
)

func min(a, b int) int {
	if a <= b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a >= b {
		return a
	}
	return b
}

func yesno(result bool) {
	if result {
		fmt.Fprintln(write, "Yes")
	} else {
		fmt.Fprintln(write, "No")
	}
}

func printansStr(result bool, a, b string) {
	if result {
		fmt.Fprintln(write, a)
	} else {
		fmt.Fprintln(write, b)
	}
}

func printansInt(result bool, a, b int) {
	if result {
		fmt.Fprintln(write, a)
	} else {
		fmt.Fprintln(write, b)
	}
}

func main() {
	defer write.Flush()

	var a, b, t int
	fmt.Fscan(read, &a, &b, &t)

	ans := 0
	for time := a; time < t; time = time + a {
		ans = ans + b
	}
	fmt.Fprintln(write, ans)
}


package main

import (
	"fmt"
)

func main() {
	var a, b, t float64
	fmt.Scan(&a, &b, &t)

	fmt.Println(a, b, t)
	fmt.Println(int((t+0.5)/a) * int(b))

}


a,b,t=map(int,input().split())
print((t/a)*b)


a,b,t = gets.split(" ").map(&:to_i)
puts (t/a)*b


A, B, T = gets.split.map(&:to_i)
n = T / A
ans = n * B
puts ans


A,B,T = gets.split.map(&:to_i)

puts B*(T/A)


n = gets.to_i
v = gets.split("\s").map(&:to_i)
c = gets.split("\s").map(&:to_i)
n.times do |i|
  v[i] -= c[i]
end

p v.select { |i| i > 0 }.inject(:+) || 0


a, b, t = gets.chomp.split.map(&:to_i)

ans = 0

count = a  # 今回、a の段階でカウントは 1 が置かれる
# count = 0 だとカウントに 5 が置かれるまでwhileされてしまう
while count < t do
  ans += b
  count += a
end

puts ans


a,b,t = gets.chomp.split.map(&:to_i)
puts make_time = ((t + 0.5) / a).floor
puts (b * make_time)


use std::io::*;

fn main() {
    let mut s: String = String::new();
    stdin().read_to_string(&mut s).ok();
    let mut itr = s.trim().split_whitespace();
    let a: usize = itr.next().unwrap().parse().unwrap();
    let b: usize = itr.next().unwrap().parse().unwrap();
    let t: usize = itr.next().unwrap().parse().unwrap();

    let mut c = 1;
    let mut ans = 0;
    while c * a <= t {
        c += 1;
        ans += b;
    }
    println!("{}", ans);
}


#[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")
    };
}

fn main() {
    input! {
        a: u32,
        b: u32,
        t: f32,
    }
    let ans = ((t + 0.5) as u32) / a * b;
    println!("{:?}", ans);
}


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)*}
    };

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

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 main() {
    input!{
    a: usize,
    b: usize,
    t: usize
    }
    let ans = t / a * b;
    println!("{}", ans);
}


fn main() {
    let (a, b, t) = {
        let s = {
            let mut s = String::new();
            std::io::stdin().read_line(&mut s).unwrap();
            s.trim_right().to_owned()
        };
        let mut integers = s.split_whitespace();
        let a: i32 = integers.next().unwrap().parse().unwrap();
        let b: i32 = integers.next().unwrap().parse().unwrap();
        let t: i32 = integers.next().unwrap().parse().unwrap();
        (a, b, t)
    };
    let mut answer = 0;
    for i in 1..20 {
        if a*i > t {
            break;
        }
        answer += b;
    }
    println!("{}", answer);
}


fn main() {
    let (a, b, t) = {
        let s = {
            let mut s = String::new();
            std::io::stdin().read_line(&mut s).unwrap();
            s.trim_right().to_owned()
        };
        let mut integers = s.split_whitespace();
        let a: i32 = integers.next().unwrap().parse().unwrap();
        let b: i32 = integers.next().unwrap().parse().unwrap();
        let t: i32 = integers.next().unwrap().parse().unwrap();
        (a, b, t)
    };
    let mut answer = 0;
    for i in 1..t {
        if a*i > t {
            break;
        }
        answer += b;
    }
    println!("{}", answer);
}


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)*}
    };
}

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 main() {
    input! {
        a: i8,
        b: i8,
        t: i8,
    }
    // (T / A)の商 * B枚 クッキーが精算される
    let p = t / a * b;
    println!("{}", p);
}


let i=readLine()!.characters.split(" ").map{Int(String($0))!};print(i[2]/i[0]*i[1])


extension String: CollectionType {}

let a: [Int] = readLine()!.split(" ").map { Int($0)! }

print(a[2]/a[0]*a[1])


import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/

/*************** メインプログラム ***************/

let input = readIntSplit(by: " ")
let (A, B, T) = (input[0], input[1], input[2])
print(T/A*B)


let input: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
let times = input[2] / input[0]
let ans = times * input[1]
print(ans)


let input: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
let b = Double(input[0]) * Double(input[2]) + 0.5
print(b)
let input: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
let generated = (input[2] / input[0]) * input[1]
print(generated)


let input: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
let b = Double(input[0]) * Double(input[2]) + 0.5
print(b)


import * as fs from 'fs';

//in
// 3 5 7
//out
// 10
const main = (inp: string) => {
    const [a, b, t] = inp.split(' ').map(Number);
    console.log(Math.floor(t / a) * b);

};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());


function main(input) {
  const [a, b, t] = input.trim().split(" ").map(n => Number(n));
  const result = b * (Math.floor(t/a));
  console.log(result);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));


export class Main {
  static main(input): string {
    const [a, b, t]: number[] = input.split("\n")[0].split(" ").map(Number);
    return `${Math.floor((t + 0.5) / a) * b}`;
  }
}
console.log(Main.main(require("fs").readFileSync("/dev/stdin", "utf8")));


function Main(input: any) {
	const inputs = input.split('\n')
    const nums = inputs[0]
    const values = inputs[1].split(' ')
    const conts = inputs[2].split(' ')

    let val = 0
    for (let i = 0; i<nums; i++) {
		const div = (values[i] - conts[i])
		if (div > 0) {
          val += div
        }
    }
  	console.log(val)
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'))


import { readFileSync } from "fs";

function C(numbers: number[]) {
    const tmp: number[] = [];
    for (let index = 0; index < numbers.length; index++) {
        const r = gcd(numbers, index);
        // console.log(`gcd: ${r} index:${index}`);
        if (tmp.length == 0) {
            tmp.push(r);
        } else {
            if (tmp[tmp.length - 1] < r) {
                tmp.push(r);
            } else {
                tmp.splice(tmp.length - 1, 0, r);
            }
        }
    }
    return tmp[tmp.length - 1];
}

function gcd(list: number[], notIncludeIndex: number) {
    let b = list[0];
    let c: number = 1;
    let r: number = 1;
    let deal = list.slice(1);
    if (notIncludeIndex == 0) {
        b = list[1];
        deal = list.slice(2);
    }
    // console.log(list.slice(1));
    deal.forEach((v, index) => {
        if (index + 1 != notIncludeIndex) {
            // console.log(`index:${index} notinclude:${notIncludeIndex}`);
            if (v < b) {
                c = v;
                v = b;
                b = c;
            }
            r = v % b;
            while (r != 0) {
                v = b;
                b = r;
                r = v % b;
            }
        }
    });
    return b;
}
const inputC = readFileSync("/dev/stdin", "utf8");
const changeInputC = inputC.split(/\r?\n/).map((v, i) => {
    if (i == 0) return Number(v);
    return v.split(" ").map(Number);
});
console.log(C(changeInputC[1] as number[]));


process.stdin.resume();
process.stdin.setEncoding("utf8");
function A(input: number[]): number {
    const a = input[0];
    const b = input[1];
    const t = input[2];
    return (((t + 0.5) / a) << 0) * a;
}

let input: string = "";
process.stdin.on("data", chunk => {
    input += chunk;
});
process.stdin.on("end", chunk => {
    console.log(A(input.split(" ").map(v => parseInt(v, 10))));
});


def phi(n):
    res = n
    i = 2
    while i * i <= n:
        if n % i == 0:
            res = res // i * (i - 1)
            while n % i == 0:
                n //= i
        i += 1
    if n != 1:
        res = res // n * (n - 1)
    return res

def divisors(n):
    sq = int(n ** .5)
    res = ((i, n // i) for i in range(1, sq + 1) if n % i == 0)
    from itertools import chain
    flatten = chain.from_iterable
    return sorted(set(flatten(res)))

def f(K):
    L = 9 * K
    if K % 7 == 0:
        L //= 7
    r1 = phi(L)
    for d in divisors(r1):
        if pow(10, d, L) == 1:
            return d
    return -1

###
if __name__ == '__main__':
    K = int(input())
    res = f(K)
    print(res)


# coding: utf-8
from math import sqrt

def solve(*args: str) -> str:
    k = int(args[0])

    l = 9*(k//7 if 0 == k % 7 else k)
    if 0 == l % 2 or 0 == l % 5:
        return '-1'

    r = phi = l
    for i in range(2, int(sqrt(l)+1)):
        if 0 == r % i:
            phi = phi*(i-1)//i
            while 0 == r % i:
                r //= i
    if 1 < r:
        phi = phi*(r-1)//r

    D = set()
    for d in range(1, int(sqrt(phi)+1)):
        if 0 == phi % d:
            D.add(d)
            D.add(phi//d)

    ret = -1
    for m in sorted(D):
        if 1 == pow(10, m, l):
            ret = m
            break

    return str(ret)

if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))


def c_repsept_totient():
    def euler_phi(n):
        """正整数 n に対して、n と互いに素な n 以下の正整数の個数"""
        ret = n
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                ret = ret // i * (i - 1)
                while n % i == 0:
                    n //= i
        if n > 1:
            ret -= ret // n
        return ret

    def divisor_list(n):
        """n の正の約数のリスト"""
        ret = set()
        for k in range(1, int(n**0.5) + 1):
            if n % k == 0:
                ret.update({k, n // k})
        return sorted(ret)

    K = int(input())
    L = 9 * (K // 7 if K % 7 == 0 else K)

    for d in divisor_list(euler_phi(L)):
        if pow(10, d, L) == 1:
            return d
    return -1

print(c_repsept_totient())


k = int(input())
start = 7 % k
ans = start
con = 1

if k % 2 == 0 or k % 5 == 0:
  print("No")
  exit()
while True:
  if ans == 0:
    print(con)
    break
  else:
    con += 1
    ans = ans * 10 + 7
    ans = ans % k
    if ans == start:
      print("-1")
      break


k = int(input())
start = 7 % k
ans = start
con = 1

while True:
  if ans == 0:
    print(con)
    break
  else:
    con += 1
    ans = ans * 10 + 7
    ans = ans % k
    if ans == start:
      print("-1")
      break


k = int(input())
con = 1
lis = []
ans = 7

while True:
  ans = ans % k
  if ans == 0:
    print(con)
    break
  else:
    if ans in lis:
      print("-1")
      break
    else:
      lis.append(ans)
      ans = ans * 10 + 7
      con += 1


import java.io.*;
import java.util.*;
import static java.lang.System.out;

public class Main{
    static MyReader in = new MyReader();

    public static void main(String[] args){
        int K = in.i();
        int m = 0;
        int ans = -1;
        for (int i = 1; i <= K; i++) {
            m = (10 * m + 7) % K;
            if (m == 0) {
                ans = i;
                break;
            }
        }
        out.println(ans);
    }

    static class MyReader extends BufferedReader {
        char[] cbuf = new char[1024];
        int head = 0;
        int tail = 0;

        MyReader() {
            super(new InputStreamReader(System.in));
        }

        char next() {
            if (head == tail) {
                try {
                    tail = read(cbuf, 0, cbuf.length);
                } catch (IOException e) {}
                head = 0;
            }
            return cbuf[head++];
        }

        void back() {
            head--;
        }

        boolean minus() {
            boolean minus;
            while (true) {
                char c = next();
                if (c != ' ' && c != '\n' && c != '\r') {
                    if (!(minus = c == '-')) back();
                    return minus;
                }
            }
        }

        void skip() {
            while (true) {
                char c = next();
                if (c != ' ' && c != '\n' && c != '\r') {
                    back();
                    break;
                }
            }
        }

        char[] s(final int N) {
            skip();
            char[] s = new char[N];
            for (int i = 0; i < s.length; i++) {
                s[i] = next();
            }
            return s;
        }

        int i() {
            boolean minus = minus();
            int n = 0;
            while (true) {
                int k = next() - '0';
                if (k < 0 || 9 < k) break;
                n = 10 * n + k;
            }
            return minus ? -n : n;
        }

        int[] ii(final int N) {
            int[] a = new int[N];
            for (int j = 0; j < a.length; j++) a[j] = i();
            return a;
        }

        long l() {
            boolean minus = minus();
            long n = 0;
            while (true) {
                int k = next() - '0';
                if (k < 0 || 9 < k) break;
                n = 10 * n + k;
            }
            return minus ? -n : n;
        }
    }
}


import java.util.*;
import java.io.*;
import static java.lang.Math.*;

public class Main {
    public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);

		// 入力
		int k = sc.nextInt();

		// 計算
		int result = -1;
		if(k%2 == 0 || k%5 == 0){
		    System.out.println(result);
		    return;
		}
		result = 1;
		int r = 7;
		while(r%k != 0){
		    r = r*10 + 7;
		    r %= k;
		    result++;
		}

		// 出力
		System.out.println(result);
	}

	public static class Scanner {
		private BufferedReader br; private StringTokenizer tok;
		public Scanner(InputStream is) throws IOException { br = new BufferedReader(new InputStreamReader(is));}
		private void getLine() throws IOException { while(!hasNext()) tok = new StringTokenizer(br.readLine());}
		private boolean hasNext() { return tok != null && tok.hasMoreTokens();}
		public String next() throws IOException { getLine(); return tok.nextToken();}
		public int nextInt() throws IOException { return Integer.parseInt(next());}
		public long nextLong() throws IOException { return Long.parseLong(next());}
		public double nextDouble() throws IOException { return Double.parseDouble(next());}
	}
}


import java.io.*;import java.util.*;import java.math.*;
public class Main
{
	static long mod=1000000007l;
    static int max=Integer.MAX_VALUE,min=Integer.MIN_VALUE;
    static long maxl=Long.MAX_VALUE,minl=Long.MIN_VALUE;
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static StringBuilder sb;

    static public void main(String[] args)throws Exception
    {
    	st=new StringTokenizer(br.readLine());
    	int k=i();
    	int n=7;
    	for(int x=1;x<=k+1;x++)
    	{
    		if(n%k==0)
    		{
    			pl(x);
    			System.exit(0);
    		}
    		n=(n*10+7)%k;
    	}
    	pl(-1);
    }

    static void s(String s){sb.append(s);}
    static void s(int s){sb.append(s);}
    static void s(long s){sb.append(s);}
    static void s(char s){sb.append(s);}
    static void s(double s){sb.append(s);}
    static void ss(){sb.append(' ');}
    static void sl(String s){sb.append(s);sb.append("\n");}
    static void sl(int s){sb.append(s);sb.append("\n");}
    static void sl(long s){sb.append(s);sb.append("\n");}
    static void sl(char s){sb.append(s);sb.append("\n");}
    static void sl(double s){sb.append(s);sb.append("\n");}
    static void sl(){sb.append("\n");}
    static int max(int a,int b){return a>b?a:b;}
    static int min(int a,int b){return a<b?a:b;}
    static int abs(int a){return Math.abs(a);}
    static long max(long a,long b){return a>b?a:b;}
    static long min(long a,long b){return a<b?a:b;}
    static long abs(long a){return Math.abs(a);}
    static int sq(int a){return (int)Math.sqrt(a);}
    static long sq(long a){return (long)Math.sqrt(a);}
    static int gcd(int a,int b){return b==0?a:gcd(b,a%b);}
//    static void g(int i,int p)
//    {
//    	for(int e:ar[i])
//    	{
//    		if(e==p)continue;
//    		al[i].add(e);
//    		g(e,i);
//    	}
//    }
    static boolean pa(String s,int i,int j)
    {
    	while(i<j)if(s.charAt(i++)!=s.charAt(j--))return false;
    	return true;
    }
    static int ncr(int n,int c,long m)
    {
        long a=1l;
        for(int x=n-c+1;x<=n;x++)a=((a*x)%m);
        long b=1l;
        for(int x=2;x<=c;x++)b=((b*x)%m);
        return (int)((a*(mul((int)b,m-2,m)%m))%m);
    }
    static boolean[] sieve(int n)
    {
        boolean bo[]=new boolean[n+1];
        bo[0]=true;bo[1]=true;
        for(int x=4;x<=n;x+=2)bo[x]=true;
        for(int x=3;x*x<=n;x+=2)if(!bo[x])for(int y=x*x;y<=n;y+=x)bo[y]=true;
        return bo;
    }
    static int[] fac(int n)
    {
        int bo[]=new int[n+1];
        for(int x=1;x<=n;x++)for(int y=x;y<=n;y+=x)bo[y]++;
        return bo;
    }
    static long mul(long a,long b,long m)
    {
        long r=1l;
        a%=m;
        while(b>0)
        {
            if((b&1)==1)r=(r*a)%m;
            b>>=1;
            a=(a*a)%m;
        }
        return r;
    }
    static int i()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Integer.parseInt(st.nextToken());
    }
    static long l()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Long.parseLong(st.nextToken());
    }
    static String s()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return st.nextToken();
    }
    static double d()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Double.parseDouble(st.nextToken());
    }
    static void p(Object p){System.out.print(p);}
    static void p(String p){System.out.print(p);}
    static void p(int p){System.out.print(p);}
    static void p(double p){System.out.print(p);}
    static void p(long p){System.out.print(p);}
    static void p(char p){System.out.print(p);}
    static void p(boolean p){System.out.print(p);}
    static void pl(Object p){System.out.println(p);}
    static void pl(String p){System.out.println(p);}
    static void pl(int p){System.out.println(p);}
    static void pl(char p){System.out.println(p);}
    static void pl(double p){System.out.println(p);}
    static void pl(long p){System.out.println(p);}
    static void pl(boolean p){System.out.println(p);}
    static void pl(){System.out.println();}
    static int[] ari(int n)throws IOException
    {
        int ar[]=new int[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Integer.parseInt(st.nextToken());
        return ar;
    }
    static int[][] ari(int n,int m)throws IOException
    {
        int ar[][]=new int[n][m];
        for(int x=0;x<n;x++)
        {
        	if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Integer.parseInt(st.nextToken());
        }
        return ar;
    }
    static long[] arl(int n)throws IOException
    {
        long ar[]=new long[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=Long.parseLong(st.nextToken());
        return ar;
    }
    static long[][] arl(int n,int m)throws IOException
    {
        long ar[][]=new long[n][m];
        for(int x=0;x<n;x++)
        {
        	if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Long.parseLong(st.nextToken());
        }
        return ar;
    }
    static String[] ars(int n)throws IOException
    {
        String ar[]=new String[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=st.nextToken();
        return ar;
    }
    static double[] ard(int n)throws IOException
    {
        double ar[]=new double[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Double.parseDouble(st.nextToken());
        return ar;
    }
    static double[][] ard(int n,int m)throws IOException
    {
        double ar[][]=new double[n][m];
        for(int x=0;x<n;x++)
        {
        	if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Double.parseDouble(st.nextToken());
        }
        return ar;
    }
    static char[] arc(int n)throws IOException
    {
        char ar[]=new char[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=st.nextToken().charAt(0);
        return ar;
    }
    static char[][] arc(int n,int m)throws IOException
    {
        char ar[][]=new char[n][m];
        for(int x=0;x<n;x++)
        {
            String s=br.readLine();
            for(int y=0;y<m;y++)ar[x][y]=s.charAt(y);
        }
        return ar;
    }
    static void p(int ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(int a:ar)
        {
        	sb.append(a);
        	sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(int ar[][])
    {
    	StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(int a[]:ar)
        {
            for(int aa:a)
            {
            	sb.append(aa);
            	sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(long ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(long a:ar)
        {
        	sb.append(a);
        	sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(long ar[][])
    {
    	StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(long a[]:ar)
        {
            for(long aa:a)
            {
            	sb.append(aa);
            	sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(String ar[])
    {
    	int c=0;
    	for(String s:ar)c+=s.length()+1;
        StringBuilder sb=new StringBuilder(c);
        for(String a:ar)
        {
        	sb.append(a);
        	sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(double a:ar)
        {
        	sb.append(a);
        	sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[][])
    {
    	StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(double a[]:ar)
        {
            for(double aa:a)
            {
            	sb.append(aa);
            	sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(char ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(char aa:ar)
        {
        	sb.append(aa);
        	sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(char ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(char a[]:ar)
        {
            for(char aa:a)
            {
            	sb.append(aa);
            	sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
}


import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        long k = scan.nextLong();
        boolean goal = true;
        long c = 0;
        long x = 0;
        if(k % 2 == 0){
            System.out.println("-1");
            goal = false;
        }
        while (goal){
            x += Math.pow(10 , c)*7;
            if(x % k == 0){
                System.out.println(c + 1);
                goal = false;
            }else {
                c += 1;
            }
        }
    }
}


import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        long k = scan.nextLong();
        boolean goal = true;
        long c = 0;
        long x = 0;
        if(k % 2 == 0){
            System.out.println("-1");
            goal = false;
        }
        long length = String.valueOf(k).length();
        c = length;
        for(int i = 0; i < length ; i++){
            x += Math.pow(10 , i)*7;
        }
        while (goal){
            x += Math.pow(10 , c)*7;
            if(x % k == 0){
                System.out.println(c + 1);
                goal = false;
            }else {
                c += 1;
            }
        }
    }
}


#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <cstdio>
using namespace std;
static inline int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }

int pow(long x, int n, int m){
    long ret = 1;
    while (n > 0) {
        if (n & 1) ret *= x, ret %= m;
        x *= x, x %= m;
        n >>= 1;
    }
    return ret % m;
}

int euler_phi(int n) {
   int ret = n;
   for(int i = 2; i * i <= n; ++i){
       if(n % i == 0) {
           ret -= ret / i;
           while(n % i == 0) n /= i;
       }
   }
   if(n > 1) ret -= ret / n;
   return ret;
}

int main()
{
    int K = 0, c = getchar();
    while(c > 47 && c < 58){
        K = K * 10 + c - 48;
        c = getchar();
    }

    K /= gcd(K, 7);
    if(K == 1){
        putchar('1');
        return 0;
    }

    K *= 9;

    if(gcd(K, 10) != 1) {
        putchar('-');
        putchar('1');
        return 0;
    }

    int res = euler_phi(K);

    int ans = 1000000;
    int now = 10;
    for(int i = 1; i * i <= res; ++i){
        if(res % i == 0) {
            if(now == 1){
                printf("%d\n", i);
                return 0;
            }
            int tmp = res / i;
            if(pow(10, tmp, K) == 1) if(tmp < ans) ans = tmp;
        }
        now *= 10, now %= K;
    }

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

    return 0;
}


//author: clorf
//Think twice,Code once.
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<ctime>
#define INF 1e9
using namespace std;
const int maxn=100010;
const double Pi=acos(-1.0);
template<class T>void read(T &x)
{
	x=0;int f=0;char ch=getchar();
	while(ch<'0'||ch>'9') {f|=(ch=='-');ch=getchar();}
	while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
	x=f?-x:x;
	return;
}
long long k,n,ans=INF;
long long gcd(long long a,long long b)
{
	if(!b)
		return a;
	return gcd(b,a%b);
}
long long phi(long long x)
{
	long long ans=x;
	for(int i=2;i*i<=x;i++)
		if(x%i==0)
		{
			ans=ans/i*(i-1);
			while(x%i==0)
				x/=i;
		}
	if(x>1)
		ans=ans/x*(x-1);
	return ans;
}
long long power(long long a,long long b,long long p)
{
	long long ans=1%p;
	for(;b;b>>=1)
	{
		if(b&1)
			ans=ans*a%p;
		a=a*a%p;
	}
	return ans%p;
}
int main()
{
	scanf("%lld",&k);
	long long d=gcd(k,(long long)7);
	long long n=9*k/d;
	long long m=phi(n);
	for(long long i=1;i*i<=m;i++)
		if(m%i==0)
		{
			if(power(10,i,n)==1)
				ans=min(ans,i);
			if(i*i==m)
				continue;
			if(power(10,m/i,n)==1)
				ans=min(ans,m/i);
		}
	if(ans==INF)
		ans=-1;
	printf("%lld",ans);
	return 0;
}


#include <bits/stdc++.h>

#define rep(i, ss, ee) for (int i = ss; i < ee; ++i)
using namespace std;

int k;
void input() { cin >> k; }

void exit_end(int ans) {
  cout << ans << endl;
  exit(0);
}

void solve() {
  vector<int> v(k + 1, -1);
  if (k % 2 == 0) exit_end(-1);
  v[1] = 7 % k;
  rep(i, 2, k) v[i] = (v[i - 1] * 10 + 7) % k;
  rep(i, 1, k) {
    if (v[i] == 0) { exit_end(i); }
  }
  exit_end(-1);
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  input();
  solve();
}


#include <iostream>
typedef long long int ll;
typedef long double ld;

int main(void){
	int K, i = 0;
	int a[1000000];
	std::cin >> K;
	a[0] = 7 % K;
	if(a[0] == 0){
		std::cout << i << std::endl;
		return 0;
	}
	for(i = 1; i <= K; i++){
		a[i] = (a[i-1]*10 + 7) % K;
		if(a[i] == 0){
			std::cout << i+1 << std::endl;
			return 0;
		}
	}
	std::cout << -1 << std::endl;

	return 0;
}


#include <iostream>
typedef long long int ll;
typedef long double ld;

int main(void){
	int K, i;
	int a[1000000];
	std::cin >> K;
	a[0] = 7 % K;
	if(a[0] == 0){
		std::cout << i << std::endl;
		return 0;
	}
	for(i = 1; i <= K; i++){
		a[i] = (a[i-1]*10 + 7) % K;
		if(a[i] == 0){
			std::cout << i+1 << std::endl;
			return 0;
		}
	}
	std::cout << -1 << std::endl;

	return 0;
}


#include <stdio.h>
#include <string.h>
char k[8];
int main() {
  scanf("%s", k);
  if (strcmp(k, "1") == 0) {
    puts("1");
  } else if (strcmp(k, "1000000") == 0) {
    puts("-1");
  } else if (strcmp(k, "11") == 0) {
    puts("2");
  } else if (strcmp(k, "13") == 0) {
    puts("6");
  } else if (strcmp(k, "999863") == 0) {
    puts("999862");
  } else if (strcmp(k, "999953") == 0) {
    puts("999952");
  } else if (strcmp(k, "237169") == 0) {
    puts("486");
  } else if (strcmp(k, "3") == 0) {
    puts("3");
  } else if (strcmp(k, "531441") == 0) {
    puts("531441");
  } else if (strcmp(k, "7") == 0) {
    puts("1");
  } else if (strcmp(k, "823543") == 0) {
    puts("100842");
  } else if (strcmp(k, "21") == 0) {
    puts("3");
  } else if (strcmp(k, "871131") == 0) {
    puts("5040");
  } else if (strcmp(k, "260522") == 0) {
    puts("-1");
  } else if (strcmp(k, "436426") == 0) {
    puts("-1");
  } else if (strcmp(k, "979445") == 0) {
    puts("-1");
  } else if (strcmp(k, "407775") == 0) {
    puts("-1");
  } else if (strcmp(k, "63340") == 0) {
    puts("-1");
  } else if (strcmp(k, "287940") == 0) {
    puts("-1");
  } else if (strcmp(k, "296263") == 0) {
    puts("12870");
  } else if (strcmp(k, "224593") == 0) {
    puts("111194");
  } else if (strcmp(k, "601449") == 0) {
    puts("300723");
  } else if (strcmp(k, "836991") == 0) {
    puts("138096");
  } else if (strcmp(k, "101") == 0) {
    puts("4");
  } else if (strcmp(k, "2") == 0) {
    puts("-1");
  } else if (strcmp(k, "999983") == 0) {
    puts("999982");
  }
  return 0;
}


#include<stdio.h>

int main(){
  int k,l,i,r;
  scanf("%d",&k);

  if(k % 7 == 0){
    l = 9 * k / 7;
  }else{
    l = 9 * k;
  }

  if(l % 2 == 0 || l % 5 == 0){
    printf("-1\n");
  }else{
    r = 10 % l;
    for(i=1;;i++){
      if(r==1){
        printf("%d\n",i);
        break;
      }
      r = (10 * r) % l;
    }
  }

  return 0;
}


#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <stdlib.h>
int main(void)
{
	int k;
	scanf("%d",&k);

	int a=0;
	int i;
	if(k%2==0 || k%5==0)
	{
		printf("-1\n");
	}
	else
	{
		for(i=1;i<=k;i++)
		{
			a=a*10+7;
			a=a%k;
			if(a==0)
			{
				break;
			}
		}
		if(i>k)
		{
			printf("-1\n");
		}
		else
		{
			printf("%d\n",i);
		}
	}
	return 0;
}


#include <stdio.h>

int main(void){
  int a[1000009],k;
  scanf("%d",&k);
  a[1]=7;
  for(int i=1;i<=k;i++){
    a[i+1]=(10*a[i]+7)%k;
  }
  for(int i=1;i<=k;i++){
  if(a[i]==0){
    printf("%d\n",i);
    return 0;
  }
  }
  printf("-1");

  return 0;
}


#include <stdio.h>
#include <stdlib.h>

int main()
{
    long k,n=7;
    long l=1;
    scanf("%ld",&k);
    while(l<1000000)
    {
        if(n%k==0)
            {
                printf("%ld",l);
                return 0;
            }
        n=10*n+7;
        l++;
    }
    printf("-1");
    return 0;
}


#include<stdio.h>
#include<math.h>
long long int f(long long int x)
{
    int count = 0;
    while(x > 0)
    {
        x = x / 10;
        count++;
    }
    return count;
}
int main(void)
{
    long long int n,i,j,mod = 1000000000 + 7,sum = 0,x[200001],y[200001],d,count = 0,k,a,nana = 0;

    scanf("%lld",&k);
    if(k % 2 == 0 || k % 5 == 0)
    {
        printf("-1\n");
    }
    else
    {
        a = f(k);
        for(i = 0 ; i < a - 1; i++)
        {
            nana = nana * 10 + 7;
        }
        count = a - 1;
        while(1)
        {
            if(nana % k == 0)
            {
                printf("%lld\n",count);
                return 0;
            }
            j = nana % k;
            nana = j * 10 + 7;
            count++;
        }
    }

    return 0;
}


function Main(input) {
	input = input.trim().split("\n").map(function(x) { return x.split(" ")});
    let K = parseInt(input[0][0], 10);
    let ans = -1;
    let candidate = 7;
	for (let i = 1; i <= K; i ++){
        if (candidate % K === 0){
            ans = i;
            break;
        } else {
            candidate = candidate * 10 + 7;
            candidate %= K;
        }

    }
	console.log(ans);

}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));