jiahuimbzuai/CoQuIR huggingface dataset:
//  [javascript]
function Main(input) {
	var studentsN = parseInt(input)
	console.log(Math.floor(studentsN / 3))
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
  var num = parseInt(input);
  
  console.log(parseInt( num / 3 ));

}
Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input) {
	var N = parseInt(input);
	console.log(Math.floor(N/3));
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
///
// File:  a.go
// Author: ymiyamoto
//
// Created on Sun Mar  4 21:00:31 2018
//
package main

import (
	"fmt"
)

var N int

func main() {
	fmt.Scan(&N)

	fmt.Println(N / 3)
}
//  [go]
package main

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

func main() {
	N := ReadInt()
	fmt.Println(N / 3)
}

var sc = bufio.NewScanner(os.Stdin)

func init()        { sc.Buffer(make([]byte, 256), 1e9); sc.Split(bufio.ScanWords) }
func Read() string { sc.Scan(); return sc.Text() }

func ReadInt() int {
	v, e := strconv.Atoi(Read())
	if e != nil {
		panic(e.Error())
	}
	return v
}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var n int
  fmt.Scanf("%d", &n)
  
  fmt.Printf("%d\n", n / 3)
}
//  [ruby]
require 'prime'
require 'set'
require 'tsort'
include Math
ALP = ('a'..'z').to_a
INF = 0xffffffffffffffff
def max(a,b);              a > b ? a : b                              end
def min(a,b);              a < b ?  a : b                             end
def swap(a,b);             a, b = b, a                                end
def gif;                   gets.to_i                                  end
def gff;                   gets.to_f                                  end
def gsf;                   gets.chomp                                 end
def gi;                    gets.split.map(&:to_i)                     end
def gf;                    gets.split.map(&:to_f)                     end
def gs;                    gets.chomp.split.map(&:to_s)               end
def gc;                    gets.chomp.split('')                       end
def pr(num);               num.prime_division                         end
def pr?(num);              Prime.prime?(num)                          end
def digit(num);            num.to_s.length                            end
def array(s,ini=nil);      Array.new(s){ini}                          end
def darray(s1,s2,ini=nil); Array.new(s1){Array.new(s2){ini}}          end
def rep(num);              num.times{|i|yield(i)}                     end
def repl(st,en,n=1);       st.step(en,n){|i|yield(i)}                 end

n = gif

puts n/3
//  [ruby]
p`dd`.to_i/3
//  [ruby]
n = gets.to_i
puts n/3
//  [rust]
use std::io;

fn main() {
    let mut buffer = String::new();
    io::stdin().read_line(&mut buffer).unwrap();

    let n = buffer.trim().parse::<i32>().unwrap();
    println!("{}", n / 3);
}
//  [rust]
extern crate core;

use std::io::{self, Read};

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let output = run(input.trim().to_string());
    println!("{}", output);
}

fn run(input: String) -> String {
    let n = input.parse::<i32>().unwrap();
    (n / 3).to_string()
}

#[test]
fn test() {
    let tests = vec![("8", "2"), ("2", "0"), ("9", "3")];
    for (i, (input, output)) in tests.into_iter().enumerate() {
        println!("test:{}", i);
        assert_eq!(run(input.to_string()), output.to_string());
    }
}
//  [rust]
#![allow(unused_imports, unused_variables, dead_code)]
use std::io::{stdin, Read, StdinLock};
use std::str::FromStr;
use std::fmt::*;
use std::str::*;
use std::cmp::*;
use std::collections::*;

// https://beta.atcoder.jp/contests/arc065/tasks/arc065_b

// 各ノードが接続しているノードを2次元配列で返す
fn node_to_list(node_num: usize, link_num: usize, sc: &mut Scanner) -> Vec<Vec<usize>> {
    let mut ret: Vec<Vec<usize>> = vec![Vec::new(); node_num];
    for i in 0..link_num {
        let (p, q): (usize, usize) = (sc.read(), sc.read());
        ret[p-1].push(q-1); ret[q-1].push(p-1);
    }
    ret
}

fn dfs(
    paths: &Vec<Vec<usize>>,
    cnct: &mut Vec<i32>,
    p: usize,
    num: i32
) {
    cnct[p] = num;
    for next in paths[p].iter() {
        if cnct[*next] == -1 {
            dfs(paths, cnct, *next, num);
        }
    }
}

fn main() {
    let cin = stdin(); let cin = cin.lock(); let mut sc = Scanner::new(cin);

    let n: i32 = sc.read();
    if n > 2 { println!("{}", n / 3); }
    else { println!("0"); }
}

struct Scanner<'a> {
    cin: StdinLock<'a>,
}
impl<'a> Scanner<'a> {
    fn new(cin: StdinLock<'a>) -> Scanner<'a> {
        Scanner { cin: cin }
    }
 
    fn read1<T: FromStr>(&mut self) -> Option<T> {
        let token = self.cin.by_ref().bytes().map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>();
        token.parse::<T>().ok()
    }
 
    fn read<T: FromStr>(&mut self) -> T {
        self.read1().unwrap()
    }
}
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const N = Number(input[0][0]);

  return Math.floor(N / 3);
};

console.log(main(read()));
//  [typescript]
import * as fs from "fs";
const input = fs.readFileSync("/dev/stdin", "utf8") as number;
console.log(input < 3 ? 0 : Math.floor(input / 3));
//  [typescript]
var lines: string[] = [];
var reader: any = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
});
reader.on("line", function (line: string) {
  lines.push(line);
});
reader.on("close", function () {
  var numN = Number(lines[0]);
  if (numN % 3 == 0) {
    console.log(numN / 3);
  } else {
    console.log(Math.floor(numN / 3));
  }
});
//  [python]
n = int(input())
a = list(map(int,input().split()))

count = 0
for i in range(len(a)):
  if (i+1)%2 ==1:
    if a[i]%2 ==1:
      count = count + 1
    else:
      pass
  else:
    continue

print(count)
//  [python]
n = int(input())
a = list(map(int, input().split(" ")))

count = 0
for i, ai in enumerate(a):
    if i%2==0 and ai%2!=0:
        count+=1
print(count)
//  [python]
n = int(input())
li = list(map(int,input().split()))
counter = 0
for i in range(n):
    if i % 2 == 0 and li[i] % 2 != 0:
        counter += 1


print(counter)
//  [python]
from heapq import *
from collections import *
import os
import sys
sys.setrecursionlimit(1<<30)
from io import BytesIO, IOBase
import math
import bisect
from math import inf

 
ins = lambda: [int(x) for x in input()]
inp = lambda: int(input())
inps = lambda: [int(x) for x in input().split()]
 
from fractions import Fraction as F
def main():
    
    n=inp()
    a=inps()

    cnt=0
    for i in range(n):
        if (i+1)&1 and a[i]&1:
            cnt+=1
    print(cnt)
    


  
 
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
 
# endregion
 
if __name__ == "__main__":
    main()
# import threading,sys
# sys.setrecursionlimit(1000000)
# threading.stack_size(1024000)
# thread=threading.Thread(target=main)
# thread.start()
//  [python]
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
# from scipy.sparse.csgraph import floyd_warshall
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations, combinations_with_replacement
from heapq import heappop, heappush, heapify
from fractions import gcd
# input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7

def main():
    n = int(input())
    a = list(map(int,input().split()))
    ans = 0
    for i in range(n):
        if i%2==0 and a[i]%2 == 1:
            ans += 1
    print(ans)
if __name__ == "__main__":
    main()
//  [python]
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    n = I()
    A = LI()
    cnt = 0
    for i, a in enumerate(A):
        if (i+1) % 2 == 1 and a % 2 == 1:
            cnt += 1
    print(cnt)



main()
//  [java]
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 n = sc.nextInt();
		
		// 計算
		int result = 0;
		for(int i = 0; i < n; i++){
		    int a = sc.nextInt();
		    if(i%2 == 0 && a%2 == 1) 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());}
	}
	
}
//  [java]
import java.io.*;
import java.util.*;

public class Main {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader s = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);

    private static int[] rai(int n) {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = s.nextInt();
        }
        return arr;
    }

    private static int[][] rai(int n, int m) {
        int[][] arr = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j] = s.nextInt();
            }
        }
        return arr;
    }

    private static long[] ral(int n) {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = s.nextLong();
        }
        return arr;
    }

    private static long[][] ral(int n, int m) {
        long[][] arr = new long[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j] = s.nextLong();
            }
        }
        return arr;
    }

    private static int ri() {
        return s.nextInt();
    }

    private static long rl() {
        return s.nextLong();
    }

    private static String rs() {
        return s.next();
    }
    static int gcd(int a,int b)
    {
        if(b==0)
        {
            return a;
        }
        return gcd(b,a%b);
    }

    public static void main(String[] args) {
        StringBuilder ans = new StringBuilder();
//        int t = ri();
        int t=1;
        while (t-- > 0) {
            int n=ri();
            int[] arr=rai(n);
            int count=0;
            for(int i=0;i<n;i++)
            {
                if(arr[i]%2==1 && i%2==0)
                {
                    count++;
                }
            }
            ans.append(count).append("\n");
        }
        out.print(ans.toString());
        out.flush();

    }

}
//  [java]
import java.io.*;
import java.util.*;

public class Main {

    private static FastReader in = new FastReader(System.in);
    private static PrintWriter out = new PrintWriter(System.out);

    private static final long MOD = (long) 1e9 + 7;

    public static void main(String[] args) {
        solve();
        out.flush();
    }

    private static void solve() {
        int n = in.nextInt();
        int[] a = in.nextIntArray(n);

        int ans = 0;
        for (int i = 0; i < n; i++) {
            if (i % 2 == 1) continue;
            if (a[i] % 2 == 1) ans++;
        }
        out.println(ans);
    }

    // https://www.geeksforgeeks.org/fast-io-in-java-in-competitive-programming/
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        FastReader(InputStream inputStream) {
            br = new BufferedReader(new
                    InputStreamReader(inputStream));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException  e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        // https://qiita.com/masakinpo/items/5f77f2a879578a85a0bb
        public int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        public long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
    }
}
//  [java]
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Scanner;

class Main {
    static final int MOD = 1000000007;
    static final int INF = 1 << 30;
    static final int ALF = 26;

    Main() {
        Scanner sc = new Scanner(System.in);
        long ans = 0;
        int N = sc.nextInt();
        int[] A = new int[N];
        for(int i=0;i<N;i++){
            A[i]=sc.nextInt();
            if(i%2==0&&A[i]%2==1)ans++;
        }
        System.out.println(ans);
    }

    public static void main(String[] args) {
        new Main();
    }
}
//  [java]
import java.util.*;
 
public class Main{
	public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
      int N = sc.nextInt();
      int[] a = new int[N];
      for(int i = 0; i < N; i++){
        a[i] = sc.nextInt();
      }
      
      int n = 0;
      for(int j = 1; j <= N; j++){
        if(j % 2 == 1 && a[j-1] % 2 == 1){
          n++;
        }
      }
      System.out.println(n);
    }
}
//  [java]
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int [] a = new int [N+1];
        int count = 0;
        
        for(int i=1; i<N+1; i++){
            a[i] = sc.nextInt();
        }
        
        for(int i=1; i<N+1; i++){
            if(i%2 == 1 && a[i]%2 == 1){
                count++;
            }
        }
        
        System.out.println(count);
    }
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
#define ll long long



int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    ll n;
    cin>>n;
    ll s=0;
    ll a;
    for(int i=1;i<=n;i++){
        cin>>a;
        if(a&1 && i&1)s++;
    }cout<<s;
}
//  [cpp]
/*input

*/


// assic value of ('0'-'9') is(48 - 57) and (a-z) is (97-122) and (A-Z) is(65-90) and 32 for space
// #pragma GCC target ("avx2")
// #pragma GCC optimization ("O3")
// #pragma GCC optimization ("unroll-loops")
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;

// order_of_key (k) : Number of items strictly smaller than k .
// find_by_order(k) : K-th element in a set (counting from zero).
using namespace __gnu_pbds;
template<class T> using oset=tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define ll          long long int
#define pb          push_back
#define pii         pair<ll ,ll >
#define vpii        vector< pii >
#define vi          vector<ll >
#define vs			vector< string >
#define vvi         vector< vector< ll > >
#define inf			(ll)1e18
#define all(it,a)   for(auto it=(a).begin();it!=(a).end();it++) 
#define F           first
#define S           second
#define sz(x)       (ll )x.size()
#define rep(i,a,b)	for(ll  i=a;i<b;i++)
#define repr(i,a,b) for(ll  i=a;i>b;i--)
#define lbnd        lower_bound
#define ubnd        upper_bound
#define mp          make_pair
#define whatis(x)   cout << #x << " is " << x << "\n";
#define graph(n)    adj(n,vector< ll > () )
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

#define debug(x)     cout << #x << " " << x << endl;
#define debug_p(x)   cout << #x << " " << x.F << " " << x.S << endl;
#define debug_v(x)   {cout << #x << " "; for (auto ioi : x) cout << ioi << " "; cout << endl;}
#define debug_vp(x)  {cout << #x << " "; for (auto ioi : x) cout << '[' << ioi.F << " " << ioi.S << ']'; cout << endl;}
#define debug_v_v(x) {cout << #x << "/*\n"; for (auto ioi : x) { for (auto ioi2 : ioi) cout << ioi2 << " "; cout << '\n';} cout << "*/" << #x << endl;}

int solve()
{
	ll n;cin>>n;
	vi a(n);
	ll cnt=0;
	rep(i,0,n)
	{
		ll x;cin>>x;
		if(!(i&1) && (x&1))cnt++;
	}
	cout<<cnt<<"\n";
	return 0;
}

int main()
{
	auto start = chrono::high_resolution_clock::now();

    // freopen("input.txt","r",stdin);
    // freopen("output.txt","w",stdout);
	
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);

	ll test_cases=1;
	//cin>>test_cases;
	while(test_cases--)
		solve();

	auto stop = chrono::high_resolution_clock::now();
	auto duration = chrono::duration_cast<chrono::milliseconds>(stop-start);
	//cout<<"\nduration: "<<(double)duration.count()<<" milliseconds";
}
//  [cpp]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

int main()
{
	int n;
	while (scanf("%d", &n) != EOF) {
		int i;
		int a, cnt;
		cnt = 0;
		for (i = 1; i <= n; i ++) {
			scanf("%d", &a);
			if (a % 2 != 0 && i % 2 != 0) {
				cnt ++;
			}
		}
		printf("%d\n", cnt);
	}
	return (0);
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define int long long
int inf = 10e17;
#define mod 1000000007

bool vis[200005];
vector<int> vec[2000005], v1;
vector<pair<int, int>> vec2[2000005];
int child[2000005];
int parent[2000005];
int div1[100005];
int min_indx[900005];
int count1 = 0;
int height = 0;
int max_indx[200005];
void dfs(int node)
{

    vis[node] = 1;

    for (int i = 0; i < vec[node].size(); i++)
    {
        if (!vis[vec[node][i]])
        {
            parent[vec[node][i]] = node;
            dfs(vec[node][i]);
        }
    }
}

int MAXN = 200005;
int LOGMAXN = (int)log2(200005) + 1;
int M[200005][60];
void process2(int A[], int N)
{
    int i, j;

    //initialize M for the intervals with length 1
    for (i = 0; i < N; i++)
        M[i][0] = i;
    //compute values from smaller to bigger intervals
    for (j = 1; 1 << j <= N; j++)
        for (i = 0; i + (1 << j) - 1 < N; i++)
            if (A[M[i][j - 1]] < A[M[i + (1 << (j - 1))][j - 1]])
                M[i][j] = M[i][j - 1];
            else
                M[i][j] = M[i + (1 << (j - 1))][j - 1];
}
//int parent[200005];
vector<int> vec1;
//bool vis[200005];
//int hei[200005];
int lev[200005];
int dis[200005];
bool cmp(pair<int, int> &a,
         pair<int, int> &b)
{
    return a.second < b.second;
}
void Ios()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    //  int t;
}
int32_t main()
{
    //  Ios();
    //  int t;
    int n;
    cin >> n;
    int ans = 0;
    int arr[n + 1];
    for (int i = 1; i <= n; i++)
    {
        cin >> arr[i];
        if (i % 2 && arr[i] % 2)
            ans++;
    }
    cout << ans << "\n";

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

int main(void) {
    int L,i,a,b;
    a=0;
    scanf("%d" ,&L);
    for (i=1; i<=L; i++) {
        scanf("%d" ,&b);
        if (i%2==1 && b%2==1) {
            a++;
        }
    }
    printf("%d\n" ,a);
    return 0;
}
//  [c]
#include <stdio.h>
int main()
{
	int N, A, index, ans = 0;
	scanf("%d", &N);
	for(index = 0;  index < N; index++)
	{
		scanf("%d", &A);
		if(A % 2 == 1)
			ans++;
		if(++index >= N)
			break;
		scanf("%d", &A);
	}
	printf("%d\n", ans);
	return 0;
}
//  [c]

#include<stdio.h> 
int main() 
{ 
  int n,x[1000],cnt=0,i; 
  scanf("%d",&n); 
  for(i=1;i<=n;i++) 
  { 
    scanf("%d",&x[i]); 
  } 
  for(i=1;i<=n;i++) { 
   if((x[i])%2!=0&& i%2!=0) 
   { 
     cnt++; 
   }  
  }
   printf("%d\n",cnt); 
   return 0; 
  
}
//  [c]
#include <stdio.h>

int main()
{
    int N[100],i,a,count = 0;

    scanf("%d",&a);

    for(i = 0;i < a;i++)
    {
        scanf("%d",&N[i]);

        if(N[i] % 2 == 1 &&(i + 1) % 2 == 1)
            count++;
    }

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

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

int main(void){

    int N,a[100]={};
    int i,count=0;

    scanf("%d",&N);
    for(i=0;i<N;i++){
        scanf("%d",&a[i]);
    }

    for(i=1;i<=N;i++){
        if(i%2==1 && a[i-1]%2==1){
            count++;
        }
    }

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

    return 0;
}
//  [javascript]
//let input = "15\n13 76 46 15 50 98 93 77 31 43 84 90 6 24 14";

function main(input){
  input = input.trim();
  let list0 = input.split("\n")[0];
  let list1 = input.split("\n")[1];
  let kousu = parseInt(list0);
  let list = list1.split(" ");
  let count = 0;
  for(let i=0; i<list.length; i++){
    list[i] = parseInt(list[i]);
    if( (i+1)%2!==0 && list[i]%2!==0 ){count++;}
  }
  console.log(count);
}
//main(input);
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict"

function Main(input) {
  
	var readlines = input.split("\n");
	var n = readlines[0];
	var a = readlines[1].split(" ").map(Number);
	var ans = 0;
	for(let i = 0; i < n; i++){
	  if(i % 2 === 0 && a[i] % 2 === 1){
	    ans++;
	  }
	}
	
	console.log(ans);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict"
{
  var input = require("fs").readFileSync("/dev/stdin", "utf8");
   
  var readlines = input.split("\n");
  var n = readlines[0];
  var a = readlines[1].split(" ").map(Number);
  var ans = 0;
  for(let i = 0; i < n; i++){
    if(i % 2 === 0 && a[i] % 2 === 1){
      ans++;
    }
  }
   
  console.log(ans);
}
//  [javascript]
'use strict'

const main = (INPUT) => {
  const input = INPUT.split('\n')
  const a = input[1].split(' ')
  let ans = 0
  for (let i = 0; i < a.length; i += 2) {
    if (a[i] % 2 == 1) {
      ans++
    }
  }
  console.log(ans)
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function Main(input){
    const num = input.split('\n')[1].split(' ').map(Number);
    let odd_count = 0;
    // 奇数のマスのみチェック
    for(let n=0; n <num.length; n+=2){
       if(num[n] % 2 == 1)
           odd_count++;
    }
    // countの数を出力
    console.log(odd_count);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

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

var sc, wr = bufio.NewScanner(os.Stdin), bufio.NewWriter(os.Stdout)

func scanString() string   { sc.Scan(); return sc.Text() }
func scanRunes() []rune    { return []rune(scanString()) }
func scanInt() int         { a, _ := strconv.Atoi(scanString()); return a }
func scanInt64() int64     { a, _ := strconv.ParseInt(scanString(), 10, 64); return a }
func scanFloat64() float64 { a, _ := strconv.ParseFloat(scanString(), 64); return a }

func scanInts(n int) []int {
	res := make([]int, n)
	for i := 0; i < n; i++ {
		res[i] = scanInt()
	}
	return res
}

func debug(a ...interface{}) { fmt.Fprintln(os.Stderr, a...) }

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}
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
}

//•*¨*•.¸¸♪main•*¨*•.¸¸♪(　-ω-)ノ　(　・ω・)
func main() {
	defer wr.Flush()
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 10000), 1001001)

	n := scanInt()
	a := scanInts(n)
	ans := 0
	for i := 0; i < n; i++ {
		if (i+1)%2 == 1 && a[i]%2 == 1 {
			ans++
		}
	}
	fmt.Fprintln(wr, ans)
}
//  [go]
package main

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

func main() {
	read := bufio.NewReader(os.Stdin)
	write := bufio.NewWriter(os.Stdout)
	defer write.Flush()
	var n int
	sum := 0
	fmt.Fscan(read, &n)
	for i := 0; i < n; i++ {
		var a int
		fmt.Fscan(read, &a)
		if i%2 == 0 && a%2 == 1 {
			sum++
		}
	}
	fmt.Fprintln(write, sum)
}
//  [go]
package main
 
import (
	"fmt"
)
 
func main() {
	var N, count, a int
	fmt.Scan(&N)
	for i := 1; i <= N; i++ {
		fmt.Scan(&a)
		if i % 2 == 1 && a % 2 == 1 {
			count++
		}
	}
    fmt.Println(count)
}
//  [go]
package main

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

func main() {
	sc := NewScanner()

	n := sc.ReadInt()
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = sc.ReadInt()
	}

	cnt := 0
	for i, ae := range a {
		if i%2 == 0 && ae%2 == 1 {
			cnt++
		}
	}

	fmt.Println(cnt)
}

// from [my library](https://github.com/ikngtty/go-contestlib)
// -   math/simple

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

func Min(values ...int) int {
	if len(values) == 0 {
		panic("no values")
	}

	min := values[0]
	for _, v := range values {
		if v < min {
			min = v
		}
	}
	return min
}

func Max(values ...int) int {
	if len(values) == 0 {
		panic("no values")
	}

	max := values[0]
	for _, v := range values {
		if v > max {
			max = v
		}
	}
	return max
}

func Pow(base, exponent int) int {
	if exponent < 0 {
		panic(fmt.Sprintf("exponent (%d) should not be a minus", exponent))
	}

	answer := 1
	for i := 0; i < exponent; i++ {
		answer *= base
	}
	return answer
}

func Ceil(divident, dividor int) int {
	if dividor == 0 {
		panic("dividor should not be 0")
	}

	quo := divident / dividor
	rem := divident % dividor

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

// -   sortutil

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

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

// -   io

type Scanner struct {
	bufScanner *bufio.Scanner
}

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

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

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

	num, err := strconv.Atoi(text)
	if err != nil {
		panic(err)
	}
	return num
}
//  [ruby]
n = gets.to_i
a = gets.split.map(&:to_i)
res = 0
a.each.with_index(1) do |i,ind|
  if ind.odd?
    res += 1 if i.odd? 
  end
end
puts res
//  [ruby]
n=gets.to_i
array = gets.split.map(&:to_i)
c=0
 
(0..n-1).each do |i|
  if (i+1).odd? && array[i].odd?
    c += 1
  end
end
 
 puts c
//  [ruby]
N = gets.to_i
p gets.split.map(&:to_i).map.with_index.count{|i,idx| (idx+1)%2==1 && i%2==1}
//  [ruby]
require 'set'; require 'prime'; require 'pp'
INF=Float::INFINITY; MOD=10**9+7
n = gets.chomp.to_i
a = gets.chomp.split.map(&:to_i)

ans = 0
n.times do |i|
  if i.even? && a[i].odd?
    ans += 1
  end
end

puts ans
//  [ruby]
#exec({'RUBY_THREAD_VM_STACK_SIZE'=>'100000000'},'/usr/bin/ruby', $0) if !ENV['RUBY_THREAD_VM_STACK_SIZE']
require 'prime'

def inpf() a=gets.chomp.split(" ").map(&:to_f)end

def inps() a=gets.chomp.split(" ")end

def copy(a) Marshal.load(Marshal.dump(a)) end

def kaijo(n,r = 10**9+7)(n < 2)? 1 : (2..n).inject{|memo,u|memo=(memo*u)%r} end

def na(n,d=0) Array.new(n,d)end

def na2(n,m,d=0) Array.new(n){Array.new(m,d)}end

def na3(n,m,l,d=0) Array.new(n){Array.new(m){Array.new(l,d)}}end

def inp() a=gets.chomp.split(" ").map(&:to_i)end

def r_up(a, b) (a+b-1)/b end

def sum(a) a.inject(:+) end

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

def small(a,b) return (a<b)? a:b end

n = inp[0]
a = inp
ans = 0
n.times do |i| 
  if i.even? and a[i].odd?
    ans += 1 
  end
end
p ans
//  [ruby]
require 'pp'

n = gets.to_i
a_n = gets.split.map(&:to_i)

count = 0
a_n.each.with_index(1) do |a, i|
    if i % 2 == 1 && a % 2 == 1
        count += 1
    end
end

puts count
//  [rust]
use proconio::{input, fastout};

#[fastout]
fn main() {
    input! {
        n: usize,
        a: [u32;n]
    }
    println!("{}",
        a.iter().enumerate()
         .filter(|(i,v)| i % 2 == 0 && *v % 2 != 0).count());
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        n: usize,
        a: [i32; n],
    }
    let mut ans: usize = 0;
    for i in 0..n {
        if i % 2 == 0 && a[i] % 2 == 1 {
            ans += 1;
        }
    }
    println!("{}", ans);
}
//  [swift]
func main() {
    let input_N = Int(readLine()!)!
    let input_aN = readLine()!.split(separator: " ").map {Int($0)!}
    var count = 0
    input_aN.enumerated().forEach({ n, x in
        if (n+1) % 2 == 1 && x % 2 == 1{
            count += 1
        }
    })
    print(count)
}

main()
//  [swift]
func readInt() -> Int {
    return Int(readLine()!)!
}

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

func mainB() {
    let _ = readInt()
    let numbers = readInts()

    var count = 0
    numbers.enumerated().forEach { (index, number) in
        if !(index + 1).isMultiple(of: 2), !number.isMultiple(of: 2) {
            count += 1
        }
    }
    print(count)
}

mainB()
//  [swift]
let n = Int(readLine()!)!
let l = readLine()!.split(separator: " ").map{Int($0)!}
var c = 0
for i in 0..<n {
    if (i+1)%2 == 1 && l[i]%2 == 1 {
        c += 1
    }
}
print(c)
//  [swift]
import Foundation

let input_line: String = readLine()!
var num = 0
let a = Int(input_line)!
var c : Int = 0
var b : [Int] = []
let  input: String = readLine()!
let split: [String] = input.components(separatedBy: " ")
split.forEach {
  b.append(Int($0)!)
}
for i in 1...a {
  if ((i % 2 == 1) && (b[i-1] % 2 == 1)) {
    num += 1
  }
}
print(num)
//  [swift]
import Foundation

let N = Int(readLine()!)!
let a = readLine()!.components(separatedBy: " ").map{ Int($0)! }
var count = 0


for i in 0...N - 1 {
    if (i + 1) % 2 != 0 && a[i] % 2 != 0 {
        count += 1
    }
}

print(count)
//  [swift]
let N = Int(readLine()!)!
let a = readLine()!.split(separator: " ").map{Int($0)!}

var count = 0
for i in 0..<N {
    if (i+1)%2==1 && a[i]%2==1 {
        count += 1
    }
}

print(count)
//  [typescript]
import * as fs from "fs"

const judge = (data :number[]) => {
    let ans:number = 0
    for (let i:number = 0; i < data.length; i++){
        if ((i+1) % 2 !== 0){
            if (data[i] % 2 !== 0){
                ans ++
            }
        }
    }
    return ans
}

export const main = () => {
    const inp:string[] = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n')
    const data:number[] = inp[1].split(' ').map((val:string) => Number(val))

    return  judge(data)
}

console.log(main())
//  [typescript]
import * as fs from "fs";

// inputで受け取り配列化する
const input = fs.readFileSync("/dev/stdin", "utf8").split("\n");

const a = input[1].split(" ").map(Number);
let cnt = 0;

for (let index = 0; index < a.length; index++) {
  const num = index + 1;
  if (num % 2 === 0) {
    continue;
  }
  if (a[index] % 2 === 0) {
    continue;
  }
  cnt++;
}

console.log(cnt);
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const N = Number(input[0][0]);
  const A = input[1].map(Number);

  let answer = 0;

  for (let i = 1; i <= N; i++) {
    if (i % 2 !== 0 && A[i - 1] % 2 !== 0) {
      answer += 1;
    }
  }

  return answer;
};

console.log(main(read()));
//  [python]
# -*- coding: utf-8 -*-
n = int(input())
print(n * 800 - (200 * int(n / 15)))
//  [python]
n = int(input())

print(n*800-n//15*200)
//  [python]
N = int(input())

print(N*800 - int(N//15)*200)
//  [python]
N=int(input())
print(N*800-200*(N//15))
//  [python]
n =int(raw_input())
print n * 800 - (n/15)*200
//  [python]
#
# 　　  ⋀_⋀　 
#　　  (･ω･)  
# .／ Ｕ ∽ Ｕ＼
#  │＊　合　＊│
#  │＊　格　＊│ 
#  │＊　祈　＊│ 
#  │＊　願　＊│ 
#  │＊　　　＊│ 
#      ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    N=I()
    print(N*800-(N//15*200))
if __name__ == '__main__':
    main()
//  [java]
import java.io.*;
import java.util.*;
class Main{
	static final long MOD = 1_000_000_007; // 10^9+7
    static final int MAX = 2_147_483_646; // intMax 
    static final int INF = 1_000_000_000; // 10^9  
    public static void main(String[] args) throws Exception {
		hayami saori = new hayami();
		int n = saori.saori_hayami();
		int num = n;
		int count = 0;
		boolean flg = true;
		while(flg){
			if(15 <= num){
				count++;
				num -= 15;
			}
			if(num < 15){
				flg = false;
			}
		}
		System.out.println(n*800 - count*200);
		saori.close();
    }
}

class hayami implements Closeable {
	private final InputStream in = System.in;
	private final byte[] hayami = new byte[1024];
	private int Hayami = 0;
	private int saori = 0;
	private boolean HayamiSaori() {
		if (Hayami < saori) {
			return true;
		}else{
			Hayami = 0;
			try {
				saori = in.read(hayami);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (saori <= 0) {
				return false;
			}
		}
		return true;
	}
	private int SaoriHayami() { 
		if (HayamiSaori()) {
            return hayami[Hayami++];
         }else{
             return -1;
         }
	}
	private static boolean hayami_saori(int hayami) { 
		return 33 <= hayami && hayami <= 126;
	}
	public boolean hayamisaori() { 
		while(HayamiSaori() && !hayami_saori(hayami[Hayami])) Hayami++; return HayamiSaori();
	}
	public String nextHayami() {
		if (!hayamisaori()) throw new NoSuchElementException();
		StringBuilder hayamin = new StringBuilder();
		int saori = SaoriHayami();
		while(hayami_saori(saori)) {
			hayamin.appendCodePoint(saori);
			saori = SaoriHayami();
		}
		return hayamin.toString();
	}
	public long saorihayami() {//nextLong
		if (!hayamisaori()) throw new NoSuchElementException();
		long hayami = 0;
		boolean misao = false;
		int saori = SaoriHayami();
		if (saori == '-') {
			misao = true;
			saori = SaoriHayami();
		}
		if (saori < '0' || '9' < saori) {
			throw new NumberFormatException();
		}
		while(true){
			if ('0' <= saori && saori <= '9') {
				hayami *= 10;
				hayami += saori - '0';
			}else if(saori == -1 || !hayami_saori(saori)){
				return misao ? -hayami : hayami;
			}else{
				throw new NumberFormatException();
			}
			saori = SaoriHayami();
		}
	}
	public int saori_hayami() {//nextInt
		long hayami = saorihayami();
		if (hayami < Integer.MIN_VALUE || hayami > Integer.MAX_VALUE) throw new NumberFormatException();
		return (int) hayami;
	}
	public double Hayamin() { //nextDouble
		return Double.parseDouble(nextHayami());
	}
	public void close() {
		try {
			in.close();
		} catch (IOException e) {
		}
    }
    
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Main {

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

        try {

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

            int eatCount = Integer.parseInt(br.readLine());

            int sumFees = 0;
            for (int i = 1; i <= eatCount; i++) {
                if (i % 15 == 0) {
                    sumFees += 600;
                } else {
                    sumFees += 800;
                }
            }

            System.out.println(sumFees);

        } catch (IOException | NumberFormatException e) {
            e.printStackTrace();
            System.exit(0);
        } catch (final Exception e) {
            e.printStackTrace();
            System.exit(0);
        }
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String s = br.readLine();
		int n = Integer.parseInt(s);

		int x = n * 800;
		int y = (n / 15) * 200;

		System.out.println(x - y);

	}
}
//  [java]
import java.util.Scanner;

/**
 * Created by User on 2017/02/18.
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();

        int x = n * 800;
        int y = 200 * (n / 15);

        System.out.println(x - y);
    }
}
//  [cpp]
#include<stdio.h>

int main(){
	int N;
	scanf("%d", &N);
	printf("%d", N * 800 - (N / 15) * 200);
	return 0;
}
//  [cpp]
#include <cstdio>
#include <algorithm>

using namespace std;
int n;

int main()
{
    scanf("%d", &n);
    printf("%d\n", n*800 - (n/15)*200);
    return 0;
}
//  [cpp]
#include "stdio.h"

int main() {
  int n;
  scanf("%d",&n);
  int a = n/15;
  printf("%d",n*800-a*200);
  return 0;
}
//  [cpp]
/* ************************************************************************
	> File Name: a.cpp
	> Author: caowushang
	> Mail: 15630929347@163.com 
	> Created Time: 2017年02月18日 星期六 20时03分11秒
 ************************************************************************/

#include<bits/stdc++.h>
using namespace std;

int main()
{
	//freopen("in","r",stdin);
	//freopen("out","w",stdout);
	int n;
	cin >> n;
	int x=n/15;
	int ans=n*800-x*200;
	cout << ans << endl;
	return 0;
}
//  [cpp]
#include<iostream>
using namespace std;
 
int main()
{
     int n,total=0;
     cin>>n;
     int g=n/15;
     total=(n*800)-(g*200);
    cout<<total<<endl;
   
    return 0;
}
//  [cpp]
#include <iostream>
#include <string>
using namespace std;

int main()
{
int n,z=0;
cin>>n;
z=800*n-((n/15)*200);
cout<<z;




    return 0;
}
//  [c]
#include <stdio.h>
int main(){
int N,i;
scanf("%d",&N);
i = N / 15;
printf("%d",(N*800)-(i*200));
return 0;
}
//  [c]
#include<stdio.h>

int main(){
	int N, x, y, i;
	scanf("%d", &N);
	x = N * 800;
	y = N / 15 * 200;
	printf("%d\n", x-y);
	return 0;
}
//  [c]
#include <stdio.h>
int main(){
	int n;
	scanf("%d",&n);
	int a=n*800;
	int b=n/15;
	printf("%d",a-b*200);
	return 0;
}
//  [c]
#include<stdio.h>

int main()
{
    int N,x,y,z;

    scanf("%d",&N);
    if(1<=N && N<=100)
    {
        y = N/15;
       z = (N*800) - (y*200);
    }
    printf("%d",z);

return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>

int main(void){

    int N;

    scanf("%d", &N);

    printf("%d\n", 800*N - 200*(N/15));

    return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main(void) {
	int i;
	int N;
	int x, y;
	char buf[128], *ch;

	fgets(buf, sizeof(buf), stdin);
	ch = strtok(buf, " ");
	N = atoi(ch);

	x = N * 800;
	y = N / 15;
	y *= 200;

	printf("%d\n", x - y);

	return 0;
}
//  [javascript]
"use strict";
const Main = (input) => {
  let xs = Number(input);
  let pay = xs * 800;
  let back = Math.floor(xs / 15);
  let ans = pay - (back * 200);
  console.log(ans);

}
Main(require('fs').readFileSync('/dev/stdin','utf8'));
//  [javascript]
function main(a){
	console.log(a*800-parseInt(a/15)*200);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict';

const input = require('fs').readFileSync('/dev/stdin', 'utf8').trim().split('\n');
const N = parseInt(input[0]);

const x = N * 800;
const y = Math.floor(N / 15) * 200;

console.log(x - y);
//  [javascript]
function Main(input) {
    console.log(input*800-Math.floor(input/15)*200);
}


Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
let n = Number(require("fs").readFileSync("/dev/stdin", "utf8"));
console.log(800 * n - 200 * ~~(n / 15));
//  [javascript]
function main(a){
	console.log(a*800-~~(a/15)*200);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import "fmt"

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

	fmt.Println(800*n - 200*(n/15))
}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var n int; fmt.Scan(&n)
  fmt.Println(800 * n - 200 * (n / 15))
}
//  [go]
package main

import "fmt"

func main() {
	var n, x, y int
	fmt.Scan(&n)
	x = 800 * n
	y = n / 15 * 200
	fmt.Println(x - y)
}
//  [go]
package main

import (
	"fmt"
)

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

	fmt.Print((n * 800) - (n/15)*200)

}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var (
		x, y int
		n    int
	)
	fmt.Scan(&n)
	x = n * 800
	y = 200 * (n / 15)
	fmt.Println(x - y)
}
//  [ruby]
n = gets.to_i; puts 800*n - 200*(n/15)
//  [ruby]
N = gets.to_i
puts N * 800 - N / 15 * 200
//  [ruby]
n = gets.to_i
x = 0
y = 0
for i in 1..n
  x +=  800
  if i % 15 == 0
    y += 200
  end
end
puts x - y
//  [ruby]
n = gets.to_i
x = n * 800
y = (n / 15) * 200
puts x - y
//  [ruby]
n = gets.chomp.to_i

puts n * 800 - (n / 15).to_i * 200
//  [ruby]
n = gets.to_i
puts n * 800 - (n/15) * 200
//  [rust]
use std::io::*;
use std::str::FromStr;

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

fn dfs(cn: usize, map: &Vec<Vec<usize>>, cnt: &mut usize, is_done: &mut Vec<bool>) {
    if is_done[cn] {
        return;
    }

    is_done[cn] = true;
    if is_done.iter().all(|&x| x == true) {
        *cnt += 1;
    }
    for i in &map[cn] {
        if is_done[*i] == true {
            continue;
        }
        let mut copy_done = is_done.clone();
        dfs(*i, map, cnt, &mut copy_done);
    }
}

fn main() {
    let n: i64 = read();
    println!("{}", n * 800 - (200 * (n / 15)))
}
//  [rust]
use std::io::*;
use std::str::FromStr;
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}
fn main(){
    let n:i32 = read();
    let mut ans:i32 = n * 800 - n / 15* 200;
    println!("{}",ans);
}
//  [rust]
use std::io;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let n:i32 = procon_read()[0];
	println!("{}", 800*n - 200*(n/15));
}
//  [rust]
#![allow(unused_imports)]

use text_io::*;
use proconio::*;
use std::collections::*;
use std::process::exit;
use std::cmp::*;
use itertools::Itertools;

fn main() {
    input! {
    a:isize,
    }
    println!("{}",a*800-(a/15*200))
}
//  [rust]
use proconio::input;

fn main() {
    input! {
        n: usize,
    };

    let ans = (800 * n) - (200 * (n / 15));
    println!("{}", ans);
}
//  [swift]
let N=Int(readLine()!)!;print(N*800-N/15*200)
//  [swift]
if let n = Int32(readLine()!) {
    print(800 * n - 200 * (n / 15))
}
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ") //ブランクで区切られている場合
 
let N = Int(split[0])!

print(800 * N - 200 * (N / 15))
//  [typescript]
var input: string = require('fs').readFileSync('/dev/stdin', 'utf8');
var inputLines: string[] = input.trim().split("\n");
var parts = inputLines[0].split(" ");

var N = parseInt(parts[0]);

console.log(800*N - 200*Math.floor(N/15));