(* Vicfred
 * https://atcoder.jp/contests/abc145/tasks/abc145_a
 * math
 * *)
let main =
    Scanf.scanf "%d" @@ fun r -> r*r |> Printf.printf "%d\n"


use std::io::Read;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();
    let n: usize = iter.next().unwrap().parse().unwrap();
    println!("{}", n * n);
}


use proconio::input;

fn main() {
    input! {
        r: usize,
    }
    println!("{}", r*r);
}


let r = Int(readLine()!)!
print(r*r)


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

let num=readInts()
let a=num[0]
print(a*a)


import Foundation

var r = 0

repeat{
    r = Int(readLine()!)!
}while(r < 0 && 100 < r)

print(r*r)


let r: Int = 100
print("%d", r * r)


export class Main {
  main(input: string): string {
    return (parseInt(input) * parseInt(input)).toString()
  }
}

console.log(new Main().main(require("fs").readFileSync("/dev/stdin", "utf8")));


import * as fs from "fs"

const r = parseInt(fs.readFileSync('/dev/stdin', 'utf-8'))

console.log(r * r/1)


import * as fs from 'fs';

const main = (inp: string) => {
    // 1*1
    const r: number = parseInt(inp, 10);
    console.log(r * r);
};

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


return r*r/1


let r: number;
let circle: number = r * r;
if (r == 0){
  return circle;
}else{
  return 0;
}


import * as fs from 'fs';

const main = (inp: string) => {
    // 1*1
    const r: number = parseInt(inp, 10);

    if (r === 1) {
        console.log(1);
    } else {
        console.log(r * 2);
    }
};

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


# ABC142C - Go to School
def main():
    N, *A = map(int, open(0).read().split())
    ans = [0] * (N + 1)
    for i, j in enumerate(A, 1):
        ans[j] = i
    print(" ".join(map(str, ans[1:])))

if __name__ == "__main__":
    main()


def main():
  import sys
  n=int(input())
  a=tuple(map(int,sys.stdin.readline().split()))
  b=[None]*n
  i=1
  for index in a:
    b[index-1]=i
    i+=1
  print(" ".join(map(str,b)))
if __name__=="__main__":
  main()


def main():
  import sys

  n=int(input())
  a=tuple(map(int,sys.stdin.readline().split()))
  b=[None]*n

  for number,index in enumerate(a,1):
    b[index-1]=number

  print(" ".join(map(str,b)))

if __name__=="__main__":
  main()


n = int(input())
a = list(map(int,input().split()))
b = []
for i in range(1, n+1):
  b.append(a.index(i) + 1)
print(*b)


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

for n in range(N):
  print(A.index(n+1)+1,end=" ")


n = int(input())
a = list(map(int, input().split()))
ans = []
for i in range(1, n+1):
    for j in range(n):
        if a[j] == i:
            ans.append(str(j+1))
print(" ".join(ans))


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author tarek
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        CGoToSchool solver = new CGoToSchool();
        solver.solve(1, in, out);
        out.close();
    }

    static class CGoToSchool {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.readInt();
            int[] a = new int[n + 1];
            for (int i = 1; i <= n; i++) {
                a[i] = in.readInt();
            }
            int[] ans = new int[n];
            for (int i = 1; i <= n; i++) {
                ans[a[i] - 1] = i;
            }
            out.printLine(ans);

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(int[] array) {
            for (int i = 0; i < array.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(array[i]);
            }
        }

        public void printLine(int[] array) {
            print(array);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        CGoToSchool solver = new CGoToSchool();
        solver.solve(1, in, out);
        out.close();
    }

    static class CGoToSchool {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.readInt();
            int[] a = in.readIntArray(n);

            int[] ans = new int[n];
            for (int i = 0; i < n; i++) {
                ans[a[i] - 1] = i + 1;
            }
            out.printLine(ans);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(int[] array) {
            for (int i = 0; i < array.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(array[i]);
            }
        }

        public void printLine(int[] array) {
            print(array);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int[] readIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++) {
                array[i] = readInt();
            }
            return array;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        CGoToSchool solver = new CGoToSchool();
        solver.solve(1, in, out);
        out.close();
    }

    static class CGoToSchool {
        public void solve(int testNumber, FastReader s, PrintWriter out) {
            int n = s.nextInt();
            int[] arr = s.nextIntArray(n);
            int[] ans = new int[n];
            int k = 1;
            for (int i = 0; i < n; i++) {
                ans[arr[i] - 1] = k++;
            }
            out.println(CGoToSchool.arrays.printArr(ans));
        }

        private static class arrays {
            static StringBuilder printArr(int[] arr) {
                StringBuilder ans = new StringBuilder();
                for (int i = 0; i < arr.length; i++) {
                    ans.append(arr[i] + " ");
                }
                return ans;
            }

        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private FastReader.SpaceCharFilter filter;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int[] nextIntArray(int n) {
            int[] array = new int[n];
            for (int i = 0; i < n; ++i) array[i] = nextInt();
            return array;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}


import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        try (Scanner in = new Scanner(System.in)) {
            int N = in.nextInt();
            int[] A = new int[N];
            for (int i = 0; i < N; i++) {
                A[i] = in.nextInt() - 1;
            }

            int[] inverse = new int[N];
            for (int i = 0; i < inverse.length; i++) {
                inverse[A[i]] = i;
            }

            for (int i = 0; i < inverse.length; i++) {
                if (i > 0) {
                    System.out.print(" ");
                }
                System.out.print(inverse[i]);
            }
            System.out.println();
        }
    }
}


import java.util.*;
public class main {
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		int n = sc.nextInt();
		int[] x=new int[n];
		int[] y=new int[n+1];
		for(int i=0;i<n;i++){
			x[i] = sc.nextInt();
			y[x[i]] = i+1;
		}
		for(int i=1;i<=n;i++)
			System.out.print(y[i]+" ");
	}
}


import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		int n = sc.nextInt();
		int[] x=new int[n];
		for(int i=0;i<n;i++)
			x[i] = sc.nextInt();
		int t = 1;
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				if(x[j]==t){
					System.out.print((j+1)+" ");
					t++;
					break;
				}
			}
		}
	}
}


//#include<bits/stdc++.h>
#include<cstdio>

using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please

const int cm = 1 << 17;
char cn[cm], * ci = cn + cm;
inline char getcha() {
	if (ci - cn == cm) { fread(cn, 1, cm, stdin); ci = cn; }
	return *ci++;
}
inline int getint() {
	char C = getcha();
	int A = C - '0';
	while ((C = getcha()) >= '0') A = A * 10 + C - '0';
	return A;
}

const int dm = 1 << 20;
char dn[dm], * di = dn;
inline void putint(ll X) {
	int keta = 0;
	char C[20];
	while (X) {
		*(C + keta) = '0' + X % 10;
		X /= 10;
		keta++;
	}
	for (int i = keta - 1; i >= 0; i--)* di++ = (*(C + i));
	*di++ = ' ';
}

int main() {
	//cin.tie(0);
	//ios::sync_with_stdio(false);

	int N = getint();
	int A[100001];
	rep1(i, N) A[getint()] = i;
	rep1(i, N) putint(A[i]);

	fwrite(dn, 1, di - dn, stdout);

	Would you please return 0;
}


#include <bits/stdc++.h>

class kin{
public:
	inline void open(FILE *,int);
	inline void close(void);
	inline void scan(void);
	inline kin &operator>(char &);
	inline kin &operator>(int &);
	inline kin &operator>(long long &);
	inline kin &operator>(double &);
	inline kin &operator>(long double &);
	inline kin &operator>(char *);
	template<class T>
	inline void get(T *,int);
private:
	FILE *fp;
	char *buf;
	int siz;
	int idx;
}in;

class kout{
public:
	inline void open(FILE *,int);
	inline void close(void);
	inline void print(void);
	inline kout &operator<(char);
	inline kout &operator<(int);
	inline kout &operator<(long long);
	inline kout &operator<(double);
	inline kout &operator<(long double);
	inline kout &operator<(const char *);
	template<class T>
	inline void put(T *,int,char,char);
private:
	FILE *fp;
	char *buf;
	int siz;
	int idx;
}out;

int main(int argc,char **argv){
	in.open(stdin,512);
	out.open(stdout,512);
	in.scan();
	int n;
	in>n;
	int d[100001];
	for(int i=1;i<=n;++i){
		int a;
		in>a;
		d[a]=i;
	}
	out.put(&d[1],n,' ','\n');
	out.print();
	in.close();
	out.close();
	return 0;
}

inline void kin::open(FILE *fparg,int sizarg){
	fp=fparg;
	buf=new char[sizarg];
	siz=sizarg;
	idx=0;
	return;
}
inline void kin::close(void){
	fp=nullptr;
	delete[] buf;
	buf=nullptr;
	siz=0;
	idx=0;
	return;
}
inline void kin::scan(void){
	int readsiz=(int)std::fread((void *)buf,(std::size_t)1,(std::size_t)siz,fp);
	if(readsiz!=siz) buf[readsiz]='\x00';
	idx=0;
	return;
}
inline kin &kin::operator>(char &var){
	if(!buf[idx]){
		var='\x00';
		return *this;
	}
	var=buf[idx];
	if(++idx==siz) scan();
	if(++idx==siz) scan();
	return *this;
}
inline kin &kin::operator>(int &var){
	if(!buf[idx]){
		var=0;
		return *this;
	}
	int sign=-1;
	if(buf[idx]=='-'){
		sign=1;
		if(++idx==siz) scan();
	}
	var=0;
	while(buf[idx]>='0'){
		var=var*10-(int)(buf[idx]-'0');
		if(++idx==siz) scan();
	}
	var*=sign;
	if(++idx==siz) scan();
	return *this;
}
inline kin &kin::operator>(long long &var){
	if(!buf[idx]){
		var=0LL;
		return *this;
	}
	long long sign=-1LL;
	if(buf[idx]=='-'){
		sign=1LL;
		if(++idx==siz) scan();
	};
	var=0LL;
	while(buf[idx]>='0'){
		var=var*10LL-(long long)(buf[idx]-'0');
		if(++idx==siz) scan();
	}
	var*=sign;
	if(++idx==siz) scan();
	return *this;
}
inline kin &kin::operator>(double &var){
	if(!buf[idx]){
		var=0.0;
		return *this;
	}
	double sign=-1.0;
	if(buf[idx]=='-'){
		sign=1.0;
		if(++idx==siz) scan();
	}
	var=0.0;
	while(buf[idx]>='0'){
		var=var*10.0-(double)(buf[idx]-'0');
		if(++idx==siz) scan();
	}
	if(buf[idx]=='.'){
		if(++idx==siz) scan();
		double dig=1.0;
		while(buf[idx]>='0'){
			var-=(double)(buf[idx]-'0')*(dig/=10.0);
			if(++idx==siz) scan();
		}
	}
	var*=sign;
	if(++idx==siz) scan();
	return *this;
}
inline kin &kin::operator>(long double &var){
	if(!buf[idx]){
		var=0.0L;
		return *this;
	}
	long double sign=-1.0L;
	if(buf[idx]=='-'){
		sign=1.0L;
		if(++idx==siz) scan();
	}
	var=0.0L;
	while(buf[idx]>='0'){
		var=var*10.0L-(long double)(buf[idx]-'0');
		if(++idx==siz) scan();
	}
	if(buf[idx]=='.'){
		if(++idx==siz) scan();
		long double dig=1.0L;
		while(buf[idx]>='0'){
			var-=(long double)(buf[idx]-'0')*(dig/=10.0L);
			if(++idx==siz) scan();
		}
	}
	var*=sign;
	if(++idx==siz) scan();
	return *this;
}
inline kin &kin::operator>(char *str){
	if(!buf[idx]){
		str[0]='\x00';
		return *this;
	}
	int ptr=0;
	while(buf[idx]>='!'){
		str[ptr++]=buf[idx];
		if(++idx==siz) scan();
	}
	str[ptr]='\x00';
	if(++idx==siz) scan();
	return *this;
}
template<class T>
inline void kin::get(T *arr,int num){
	for(int i=0;i<num;++i) (*this)>arr[i];
	return;
}

inline void kout::open(FILE *fparg,int sizarg){
	fp=fparg;
	buf=new char[sizarg];
	siz=sizarg;
	idx=0;
	return;
}
inline void kout::close(void){
	fp=nullptr;
	delete[] buf;
	buf=nullptr;
	siz=0;
	idx=0;
	return;
}
inline void kout::print(void){
	std::fwrite((void *)buf,(std::size_t)1,(std::size_t)idx,fp);
	idx=0;
	return;
}
inline kout &kout::operator<(char val){
	buf[idx]=val;
	if(++idx==siz) print();
	return *this;
}
inline kout &kout::operator<(int val){
	if(val<0){
		buf[idx]='-';
		if(++idx==siz) print();
	}
	else val*=-1;
	char dig[10];
	int ptr=0;
	do{
		int tmp=val/10;
		dig[ptr++]=(char)-(val-tmp*10)+'0';
		val=tmp;
	}while(val);
	while(ptr--){
		buf[idx]=dig[ptr];
		if(++idx==siz) print();
	}
	return *this;
}
inline kout &kout::operator<(long long val){
	if(val<0LL){
		buf[idx]='-';
		if(++idx==siz) print();
	}
	else val*=-1LL;
	char dig[19];
	int ptr=0;
	do{
		long long tmp=val/10LL;
		dig[ptr++]=(char)-(val-tmp*10LL)+'0';
		val=tmp;
	}while(val);
	while(ptr--){
		buf[idx]=dig[ptr];
		if(++idx==siz) print();
	}
	return *this;
}
inline kout &kout::operator<(double val){
	if(val<0.0){
		buf[idx]='-';
		if(++idx==siz) print();
	}
	else val*=-1.0;
	double dig=1.0;
	while(val/dig<=-10.0) dig*=10.0;
	int tmp;
	while(dig>=1.0){
		buf[idx]=(char)-(tmp=(int)(val/dig))+'0';
		if(++idx==siz) print();
		val-=(double)tmp*dig;
		dig/=10.0;
	}
	buf[idx]='.';
	if(++idx==siz) print();
	for(int i=0;i<12;++i){
		buf[idx]=(char)-(tmp=(int)(val/dig))+'0';
		if(++idx==siz) print();
		val-=(double)tmp*dig;
		dig/=10.0;
	}
	return *this;
}
inline kout &kout::operator<(long double val){
	if(val<0.0L){
		buf[idx]='-';
		if(++idx==siz) print();
	}
	else val*=-1.0L;
	long double dig=1.0L;
	while(val/dig<=-10.0L) dig*=10.0L;
	int tmp;
	while(dig>=1.0L){
		buf[idx]=(char)-(tmp=(int)(val/dig))+'0';
		if(++idx==siz) print();
		val-=(long double)tmp*dig;
		dig/=10.0L;
	}
	buf[idx]='.';
	if(++idx==siz) print();
	for(int i=0;i<16;++i){
		buf[idx]=(char)-(tmp=(int)(val/dig))+'0';
		if(++idx==siz) print();
		val-=(long double)tmp*dig;
		dig/=10.0L;
	}
	return *this;
}
inline kout &kout::operator<(const char *str){
	for(int i=0;str[i];++i){
		buf[idx]=str[i];
		if(++idx==siz) print();
	}
	return *this;
}
template<class T>
inline void kout::put(T *arr,int num,char dlm,char end){
	--num;
	for(int i=0;i<num;++i) (*this)<arr[i]<dlm;
	(*this)<arr[num]<end;
	return;
}


#pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>
using namespace std;
inline void rd(int &x){
  int k;
  int m=0;
  x=0;
  for(;;){
    k = getchar_unlocked();
    if(k=='-'){
      m=1;
      break;
    }
    if('0'<=k&&k<='9'){
      x=k-'0';
      break;
    }
  }
  for(;;){
    k = getchar_unlocked();
    if(k<'0'||k>'9'){
      break;
    }
    x=x*10+k-'0';
  }
  if(m){
    x=-x;
  }
}
inline void wt_L(char a){
  putchar_unlocked(a);
}
inline void wt_L(int x){
  int s=0;
  int m=0;
  char f[10];
  if(x<0){
    m=1;
    x=-x;
  }
  while(x){
    f[s++]=x%10;
    x/=10;
  }
  if(!s){
    f[s++]=0;
  }
  if(m){
    putchar_unlocked('-');
  }
  while(s--){
    putchar_unlocked(f[s]+'0');
  }
}
int N;
int A[100000];
int res[100000];
int main(){
  int i;
  rd(N);
  {
    int Lj4PdHRW;
    for(Lj4PdHRW=(0);Lj4PdHRW<(N);Lj4PdHRW++){
      rd(A[Lj4PdHRW]);A[Lj4PdHRW] += (-1);
    }
  }
  for(i=(0);i<(N);i++){
    res[A[i]] = i+1;
  }
  {
    int KL2GvlyY;
    if(N==0){
      putchar_unlocked('\n');
    }
    else{
      for(KL2GvlyY=(0);KL2GvlyY<(N-1);KL2GvlyY++){
        wt_L(res[KL2GvlyY]);
        wt_L(' ');
      }
      wt_L(res[KL2GvlyY]);
      wt_L('\n');
    }
  }
  return 0;
}
// cLay varsion 20190929-1

// --- original code ---
// int N, A[1d5], res[1d5];
// {
//   rd(N,(A--)(N));
//   rep(i,N) res[A[i]] = i+1;
//   wt(res(N));
// }


#include <bits/stdc++.h>

using namespace std;

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int n;
    cin >> n;
    vector<int> timing(n), order(n);
    for(int i = 0; i < n; i++)
        cin >> timing[i];
    for(int i = 0; i < n; i++)
        order[timing[i] - 1] = i + 1;
    for(int i = 0; i < n; i++)
        cout << order[i];
    return 0;
}


#include <bits/stdc++.h>

using namespace std;
#define NIL -1
#define ll long long
#define MAX 100
#define pb push_back

int main() {
	int n;
	cin >> n;
	double arr[n];
	for(int i=0; i<n; i++) {
		cin >> arr[i];
	}
	sort(arr, arr+n);
	double ans = 0;
	for(int i=0; i<n-1; i++) {
		ans = ((arr[i]+arr[i+1])/2.0);
		arr[i+1] = ans;
	}
	cout << setprecision(10) << arr[n-1] << endl;
    return 0;
}


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

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n;
	int a[n], ans[n];
	cin >> n;
	for(int i=0;i<n;i++)
		cin >> a[i];
	for(int i=0;i<n;i++)
		ans[a[i]-1]=i+1;
	for(int i=0;i<n;i++)
		cout << ans[i] << " " << endl;
	return 0;
}


int main(){
  int n;
  scanf("%d",&n);
  int a[100001],b[100001];
  for(int i=0;i<n;i++){
    scanf("%d",&a[i]);
    b[a[i]-1]=i+1;
  }
  for(int i=0;i<n;i++){
    printf("%d\n",b[i]);
  }
}


int main(void){
  int n,a[100000],b[100000]={};

  scanf("%d",&n);

  for(int i = 0; i < n; i++){
    scanf("%d",&a[i]);
    b[a[i]-1] = i+1;
  }

  for(int i = 0; i < n; i++)
    printf("%d ",b[i]);

  return 0;
}


// AtCoder165 C

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
#include <memory.h>
#include <malloc.h>
#include <stdlib.h>

// qsortで用いる比較用関数．*a<*bならaが先になる．
int compare(const void* a, const void* b) {
    return *(int*)a - *(int*)b;
}

int revcompare(const void* a, const void* b) {
    return *(int*)b- *(int*)a;
}

int main() {
    int i,j;
    int n;
    int a;
    int* order;

    scanf("%d", &n);
    order = (int*)malloc(sizeof(int) * n);

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

    for(i=0;i<n;i++){
        printf("%d ", order[i]);
    }

    return 0;
}


#include <stdio.h>

int main(void){
  int n;
  int a[100005];

  scanf("%d", &n);
  int i=0;
  for(i=0;i<n;i++){
    scanf("%d", &a[i]);
  }
  /*
  while(a != '\0'){
    scanf("%d", &a[i]);
  }
  */

  int temp = 0;
  int j=0;

  for(i=0;i<n;i++){
      for(j=0;j<n; j++){
    	if(a[j]==i+1){
      		printf("%d ", j+1);
    	}
      }
  }

    return 0;
  }


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

int main ()
{
  int n,i,j;
  int *a;

  scanf("%d",&n );
  a = calloc(n,sizeof(int));

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

  for(i=1; i<=n; i++){
    for(j=0; j<n; j++){
      if(a[j] == i)
        printf("%d ",j+1 );
    }
  }

  free(a);
  return 0;
}


#include<stdio.h>
int main()
{
	int n,d,e,i,j,a[100000],b[100000],c[100000];
	scanf("%d",&n);
	for(i=0;i<n;i++){
		scanf("%d",&a[i]);
		b[i]=a[i];
	}
	for(i=0;i<n-1;i++){
		for(j=i+1;j<n;j++){
			if(a[i]>=a[j]){
				d=a[i];
				a[i]=a[j];
				a[j]=d;
			}
		}
	}
	e=0;
	for(i=0;i<n;i++){
		for(j=0;j<n;j++){
			if(a[i]==b[j]){
				e++;
				c[i]=e;
			}
			else e++;
		}
		e=0;
	}
	for(i=0;i<n;i++){
		printf("%d ",c[i]);
	}
	return 0;
}


const main = input =>{
    const IN = input.split("\n");
    const N = parseInt(IN[0]);
    const A = IN[1].split(" ");

    var array1 = new Array(N);

    for(var i=0; i<N; i++){

        array1[A[i]- 1] = i + 1;
    }
   // console.log(array1);
  console.log(array1.join(' '));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


"use strict";

main(require("fs").readFileSync("/dev/stdin", "UTF-8"));

function main(input) {
  let students_num = parseInt(input.split("\n")[0]); //生徒数
  let arrive_num_order_by_student_num = input.split("\n")[1].split(" "); //学番の順の到着順(配列)

  let result = new Array(students_num); //出力

  for (let i = 0; i < students_num; i++) {
    result[parseInt(arrive_num_order_by_student_num[i]) - 1] = i + 1;
  }

  console.log(result.join(" "));
}


process.stdin.resume();
process.stdin.setEncoding('utf8');

var lines = []
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

reader.on('line', (line) => {
  lines.push(line);
});

reader.on('close', () => {
 var n = Number(lines[0]);
 var a = lines[1].split(' ');
 var ans = new Array(n);
 for(i=1; i<=n; i++){
   ans[a[i-1]-1] = i;
   // console.log(index);
 }
 console.log(ans.join(' '));
});


process.stdin.resume();
process.stdin.setEncoding('utf8');

var lines = []
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

reader.on('line', (line) => {
  lines.push(line);
});

reader.on('close', () => {
 var n = Number(lines[0]);
 var a = lines[1].split(' ');
 var ans = new Araay(n);
 for(i=1; i<=n; i++){
   ans[a[i-1]-1] = i;
   // console.log(index);
 }
 console.log(ans.join(' '));
});


process.stdin.resume();
process.stdin.setEncoding('utf8');

var lines = []
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

reader.on('line', (line) => {
  lines.push(line);
});

reader.on('close', () => {
 var n = Number(lines[0]);
 var a = lines[1].split(' ');
 var ans = [];
 for(i=1; i<=n; i++){
   var index = a.indexOf(String(i));
   // console.log(index);
   ans.push(index+1);
 }
 console.log(ans.join(' '));
});


'use strict';
function main(input) {
  const args = input.split('\n'),
        N = parseInt(args[0]),
        A = args[1].split(' ');
  let order = [];
  for (let i = 1; i <= N; ++i) {
    order.push(A.indexOf(i.toString())+1);
  }
  let answer = '';
  for (let i = 0; i < N; ++i) {
    if (i < N-1) {
      answer += order[i] + ' ';
    } else {
      answer += order[i];
    }
  }
  console.log(answer);
}

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


package main

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

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	sc.Scan()
	n, _ := strconv.Atoi(sc.Text())
	slice := make([]string, n)
	for i := 1; i <= n; i++ {
		sc.Scan()
		a, _ := strconv.Atoi(sc.Text())
		b := strconv.Itoa(i)
		slice[a-1] = b
	}
	fmt.Print(strings.Join(slice, " "))
	fmt.Println("")
}


package main

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

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	sc.Scan()
	n := mustAtoi(sc.Text())
	answer := make([]string, n)
	for i := 0; i < n; i++ {
		sc.Scan()
		answer[mustAtoi(sc.Text())-1] = strconv.Itoa(i + 1)
	}
	fmt.Print(strings.Join(answer, " "))
}

func mustAtoi(s string) int {
	i, err := strconv.Atoi(s)
	if err != nil {
		panic(err)
	}
	return i
}


package main

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

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Buffer([]byte{}, 100000000)
	sc.Scan()
	_ = sc.Text()
	sc.Scan()
	an := strings.Split(sc.Text(), " ")
	answer := make([]string, len(an))
	for i, a := range an {
		answer[mustAtoi(a)-1] = strconv.Itoa(i + 1)
	}
	fmt.Println(strings.Join(answer, " "))
}

func mustAtoi(s string) int {
	i, err := strconv.Atoi(s)
	if err != nil {
		panic(err)
	}
	return i
}


package main

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

var sc = bufio.NewScanner(os.Stdin)

func contains(target string, list []string) bool {
	for _, r := range list {
		if target == r {
			return true
		}
	}
	return false
}

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

func nextInt() int {
	sc.Scan()

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

	i, e := strconv.ParseInt(sc.Text(), 10, 64)
	if e != nil {
		panic(e)
	}
	return i
}

func nextF64() float64 {
	sc.Scan()

	i, e := strconv.ParseFloat(sc.Text(), 64)
	if e != nil {
		panic(e)
	}
	return i
}

func isInteger(x float64) bool {
	return math.Floor(x) == x
}

func Ave(s []int) int {
	val := 0
	for _, i := range s {
		val += i
	}
	return int(val / len(s))
}
func cal(i int) (sum int) {
	for i != 0 {
		sum += i % 10
		i /= 10
	}
	return
}
func max(a []int) (idx int, val int) {
	max := a[0]
	idx = 0
	for j, i := range a {
		if max < i {
			max = i
			idx = j
		}
	}
	return idx, max
}

func draw(i int, a []int) (l []int) {
	// p = a[i]
	for j := i; j < len(a); j++ {
		if j != len(a)-1 {
			a[j] = a[j+1]
		} else if j == len(a)-1 {
			a = a[:len(a)-1]
		}
	}
	return a
}
func abs(i int64) int64 {
	if i < 0 {
		return -i
	}
	return i
}

func main() {
	sc.Split(bufio.ScanWords)
	// sc.Buffer([]byte{}, math.MaxInt64)
	// a := make([][]int, 3)
	// for i := 0; i < 3; i++ {
	// 	a[i] = make([]int, 3)
	// }
	// for i := 0; i < 3; i++ {
	// 	for j := 0; j < 3; j++ {
	// 		a[i][j] = nextInt()
	// 	}
	// }
	n := nextInt()
	// var cnt int
	var a []int
	var out []string

	for i := 0; i < n; i++ {
		a = append(a, nextInt())
	}

	for i := 1; i <= len(a); i++ {
		for idx, val := range a {
			if val == i {
				out = append(out, strconv.Itoa(idx+1))
			}
		}
	}
	fmt.Println(strings.Join(out, " "))

}


package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	nums := make([]int, n)
	ans := make([]int, n)
	for i, _ := range nums{
		fmt.Scan(&nums[i])
	}

	for i:=1; i<=n; i++{
		for j:=0; j<n; j++{
			if i == nums[j]{
				ans[i-1] = j+1
				break
			}
		}
	}

	for _, v := range ans{
		fmt.Println(v)
	}
}


package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	nums := make([]int, n)
	ans := make([]int, n)
	for i, _ := range nums{
		fmt.Scan(&nums[i])
	}

	for i:=1; i<=n; i++{
		for j:=0; j<n; j++{
			if i == nums[j]{
				ans[i-1] = j+1
			}
		}
	}

	for _, v := range ans{
		fmt.Println(v)
	}
}


N = gets.chomp.to_i
cms = gets.chomp

cms_arr = cms.split
result = []

for i in 0..cms_arr.size - 1
    result[cms_arr[i].to_i - 1] = (i + 1).to_s
end

puts result.join(" ")


# 入力を取得
N = gets
A = gets

A_arry = A.split(" ")
result = []

for i in 0..N.to_i-1
    result[A_arry[i].to_i-1] = (i+1).to_s
end

# 結果を出力
print result.join(" ")


input_lines = readlines

N = input_lines[0].to_i
A = input_lines[1].split(' ')

cnt = 1
array = [N]

A.each do |num|
  array[num.to_i-1] = cnt
  cnt = cnt +1
end

puts array.join(' ')


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

b=Array.new(n)
n.times do |i|
    b[i]=a.index(i+1)+1
end
puts b.join(" ")


N = gets.to_i
a = gets.split.map &:to_i

str = ""
N.times do |i|
  idx = a.find_index { |n| n == i+1 }
  str << (idx + 1).to_s + " "
end

puts str.strip


n=gets.to_i
s=gets.split.map &:to_i
puts s.zip(1..n).map{|x|x[1]}*" "


/*------------------------------------------------------------------*/
/*------------------------- begin template -------------------------*/
/*------------------------------------------------------------------*/

// ref: tanakh <https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8>
// diff: using Parser
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut parser = Parser::from_str($s);
        input_inner!{parser, $($r)*}
    };
    (parser = $parser:ident, $($r:tt)*) => {
        input_inner!{$parser, $($r)*}
    };
    (new_stdin_parser = $parser:ident, $($r:tt)*) => {
        let stdin = std::io::stdin();
        let reader = std::io::BufReader::new(stdin.lock());
        let mut $parser = Parser::new(reader);
        input_inner!{$parser, $($r)*}
    };
    ($($r:tt)*) => {
        input!{new_stdin_parser = parser, $($r)*}
    };
}

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

macro_rules! read_value {
    ($parser:ident, ( $($t:tt),* )) => {
        ( $(read_value!($parser, $t)),* )
    };
    ($parser:ident, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($parser, $t)).collect::<Vec<_>>()
    };
    ($parser:ident, chars) => {
        read_value!($parser, String).chars().collect::<Vec<char>>()
    };
    ($parser:ident, char_) => {
        read_value!($parser, String).chars().collect::<Vec<char>>()[0]
    };
    ($parser:ident, usize1) => {
        read_value!($parser, usize) - 1
    };
    ($parser:ident, i64_) => {
        $parser.fast_i64()
    };
    ($parser:ident, usize_) => {
        $parser.fast_i64() as usize
    };
    ($parser:ident, usize1_) => {
        ($parser.fast_i64() - 1) as usize
    };
    ($parser:ident, $t:ty) => {
        $parser.next::<$t>().expect("Parse error")
    };
}

use std::io;
use std::io::BufRead;
use std::str;

// ref: tatsuya6502 <https://qiita.com/tatsuya6502/items/cd448486f7ef7b5b8c7e>
// ref: wariuni <https://qiita.com/tatsuya6502/items/cd448486f7ef7b5b8c7e#comment-7040a5ae96305e884eb9>
// diff: using std::io::BufRead::fill_buf()
pub struct Parser<R> {
    pub reader: R,
    buf: Vec<u8>,
    pos: usize,
}

impl Parser<io::Empty> {
    pub fn from_str(s: &str) -> Parser<io::Empty> {
        Parser {
            reader: io::empty(),
            buf: s.as_bytes().to_vec(),
            pos: 0,
        }
    }
}

impl<R: BufRead> Parser<R> {
    pub fn new(reader: R) -> Parser<R> {
        Parser {
            reader: reader,
            buf: vec![],
            pos: 0,
        }
    }
    pub fn update_buf(&mut self) {
        self.buf.clear();
        self.pos = 0;
        loop {
            let (len, complete) = {
                let buf2 = self.reader.fill_buf().unwrap();
                self.buf.extend_from_slice(buf2);
                let len = buf2.len();
                (len, buf2[len - 1] <= 0x20)
            };
            self.reader.consume(len);
            if complete {
                break;
            }
        }
    }
    pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {
        loop {
            let mut begin = self.pos;
            while begin < self.buf.len() && (self.buf[begin] <= 0x20) {
                begin += 1;
            }
            let mut end = begin;
            while end < self.buf.len() && (self.buf[end] > 0x20) {
                end += 1;
            }
            if begin != self.buf.len() {
                self.pos = end;
                return unsafe { str::from_utf8_unchecked(&self.buf[begin..end]) }.parse::<T>();
            } else {
                self.update_buf();
            }
        }
    }
    pub fn fast_i64(&mut self) -> i64 {
        loop {
            let mut begin = self.pos;
            while begin < self.buf.len() && (self.buf[begin] <= 0x20) {
                begin += 1;
            }
            if begin == self.buf.len() {
                self.update_buf();
                continue;
            }
            let mut res = 0;
            let (is_positive, mut end) = match self.buf[begin] {
                b'+' => (true, begin + 1),
                b'-' => (false, begin + 1),
                _ => (true, begin),
            };
            while end < self.buf.len() && (self.buf[end] > 0x20) {
                res = res * 10 + (self.buf[end] as i64 - '0' as i64);
                end += 1;
            }
            if begin != self.buf.len() {
                self.pos = end;
                return if is_positive { res } else { -res };
            } else {
                self.update_buf();
            }
        }
    }
}

#[allow(unused_imports)]
use std::cmp::*;
use std::fmt::Display;
use std::fmt::Write;

pub fn writeln_vec<T: Display>(s: &mut String, xs: &Vec<T>) {
    if xs.len() == 0 {
        writeln!(s, "");
    } else {
        write!(s, "{}", xs[0]);
        for x in xs.iter().skip(1) {
            write!(s, " {}", x);
        }
        writeln!(s, "");
    }
}

fn main() {
    input! {
        new_stdin_parser = parser,
    }
    let res = solve(&mut parser);
    print!("{}", res);
}

/*------------------------------------------------------------------*/
/*-------------------------- end template --------------------------*/
/*------------------------------------------------------------------*/

fn solve<R: BufRead>(parser: &mut Parser<R>) -> String {
    let mut buf = String::new();
    input! {
        parser = parser,
        n: usize,
        xs: [usize1; n],
    }
    let mut ys = vec![0; n];
    for (i, &x) in xs.iter().enumerate() {
        ys[x] = i + 1;
    }
    writeln_vec(&mut buf, &ys);
    buf
}


use std::fmt::Write;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|s| s.parse().ok().unwrap())
        .collect()
}

fn main() {
    let n = read::<usize>();
    let ax = read_vec::<usize>();

    let mut v = vec![0; n];

    for (i, &a) in ax.iter().enumerate() {
        v[a-1] = i + 1;
    }

    let mut ans = String::new();

    write!(ans, "{}", v[0]).unwrap();

    for i in v.iter().skip(1) {
        write!(ans, " {}", i).unwrap();
    }

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


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

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

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

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

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

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

use std::io::{stdout, Write, BufWriter};
// use std::cmp::min;

fn main() {
    input!{
        n: usize,
        rec: [i32; n],
    }
    let out = stdout();
    let mut out = BufWriter::new(out.lock());

    let mut ans: Vec<usize> = vec![0; n];
    for (i, &n) in rec.iter().enumerate() {
        ans[(n - 1) as usize] = i + 1;
    }
    for i in ans {
        writeln!(out, "{} ", i).unwrap();
    }
}


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("filed 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:usize = read();
    let mut ans = vec![0; n];
    for i in 1..=n {
        ans[read::<usize>()-1] = i;
    }
    println!("{}", format!("{:?} ", ans));
}


use proconio::{fastout, input};

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

    for i in 1..n + 1 {
        let index = a.iter().position(|&r| r == i).unwrap();
        print!("{} ", index + 1);
    }
}


use proconio::{fastout, input};

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

    for i in 1..n + 1 {
        let index = a.iter().position(|&r| r == i).unwrap();
        print!("{}", index + 1);
    }
}


// 🐋💭 Walk on Multiplication Table
import Foundation

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

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

///最大公約数を返す
func gcd(_ m:Int, _ n:Int) -> Int {
    if n == 0 {return m}
    return gcd(n, 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://melheaven.hatenadiary.jp/entry/atcoder144
///約数の配列を返す
func makeDivisors(_ n:Int) -> [Int] {
    var divisors = [Int]()
    for i in 1..<Int(pow(Double(n), 0.5)) + 1 {
        if n % i == 0{
            divisors.append(i + n / i)
        }
    }

    return divisors
}

func main() {
    let n = readInt()
    let aryA = readLine()!.split(separator: " ").map { String($0) }
    var ans = [String](repeating: String(), count: n)

    for i in 0..<n {
        let a = aryA[i]
        ans[Int(a)! - 1] = String(i + 1)
    }
    print(ans.joined(separator: " "))
}
main()


readLine()
var a=readLine()!.characters.split(" ").enumerate().map{($0.0,Int(String($0.1))!)}
a.sort{$0.1<$1.1}.map{print($0.0+1)}


readLine()
readLine()!.characters.split(" ").enumerate().map{($0.0,Int(String($0.1))!)}.sort{$0.1<$1.1}.map{print($0.0+1)}


// 🐋💭 Walk on Multiplication Table
import Foundation

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

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

///最大公約数を返す
func gcd(_ m:Int, _ n:Int) -> Int {
    if n == 0 {return m}
    return gcd(n, 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://melheaven.hatenadiary.jp/entry/atcoder144
///約数の配列を返す
func makeDivisors(_ n:Int) -> [Int] {
    var divisors = [Int]()
    for i in 1..<Int(pow(Double(n), 0.5)) + 1 {
        if n % i == 0{
            divisors.append(i + n / i)
        }
    }

    return divisors
}

func main() {
    let n = readInt()
    let aryA = readLine()!.split(separator: " ").map { String($0) }
    var ans = String()

    for i in 1...n {
        let a = aryA.firstIndex(of: String(i))!
        ans +=  "\((Int(a) + 1)) "
    }
    print(ans)
}
main()


import Foundation

let n = Int(readLine()!)!
let input_num = readLine()!

var aList:[String] = []
aList = input_num.componentsSeparatedByString(" ")

var answer:[Int] = []
var count:Int = 1
for i in 1...n {
	for j in 0..<n {
    	if Int(aList[j]) != i {
        	count += 1
    	} else {
    	answer.append(count)
        count = 1
        break
        }
    }
}

var str:[String] = []

for i in 0..<n {
	str.append(String(answer[i]))
}

print(str.joinWithSeparator(" "))


import Foundation

let n = Int(readLine()!)!
let input_num = readLine()!

var aList:[String] = []
aList = input_num.componentsSeparatedByString(" ")

print(aList)

var answer:[Int] = []
var count:Int = 1
for i in 1...n {
	for j in 0..<n {
    	if Int(aList[j]) != i {
        	count += 1
    	} else {
    	answer.append(count)
        count = 1
        break
        }
    }
}

print(answer)


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[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.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[]=>{return Array.from(new Set(a))};
const main=()=>{
  let n=tn()
  let ar=tnn(n)
  let br=new Array(n)
  for(let i=0;i<n;i++){
    br[ar[i]-1]=i+1
  }
  to(br.join(' '))
}
main()


import { readFileSync } from 'fs'
function main() {
  const input = readFileSync('/dev/stdin', 'utf8')
  const data = input.split('\n').map(v => v.trim())
  const n = Number(data[0].trim())
  const students = data[1].trim().split(' ').map(v => Number(v))
  const order = new Array(n)
  for (let i = 0; i < n; i++) {
    const position = students[i] - 1
    order[position] = i + 1
  }
  console.log(order.join(' '))
}
main()


function main(input) {
    const n: number = parseInt(input.split('\n')[0], 10);
    const r: number[] = new Array(n).fill(0);
    const a: number[] = input.split('\n')[1].split(' ').map((v: string) => parseInt(v));
    a.forEach((e: number, i: number) => {
        r[e-1] = i+1;
    });
    console.log(r.join(' '));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


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[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.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[]=>{return Array.from(new Set(a))};
const main=()=>{
  let n=tn()
  let ar=tnn(n)
  let br=new Array(n)
  for(let i=0;i<n;i++){
    br[ar[i]-1]=i+1
  }
  to(br.join(''))
}
main()


function main(input) {
    const n: number = parseInt(input.split('\n')[0], 10);
    const r: number[] = new Array(n).fill(0);
    const a: number[] = input.split('\n')[1].split(' ').map((v: string) => parseInt(v));
    a.forEach((e: number, i: number) => {
        r[e-1] = i+1;
    });
    console.log(r);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


n = int(input())
a_list = [int(a) for a in input().split(' ')]
bin_or = 0
for a in a_list:
    bin_or |= a
cnt = 0
while bin_or & 1 != 1:
    cnt += 1
    bin_or >>= 1
print(cnt)


N=input()
S=map(int,input().split())
sum=0
for num in S:
  sum=sum|num

for i in range(200):
  if sum>>i&1==1:
    print(i)
    break


n=int(input())
ans=min(map(lambda x:bin(int(x))[::-1].index('1'),input().split()))
print(ans)


n = int(input())
a = list(map(int, input().split()))
cnt = 0

while all(i%2==0 for i in a ):
  A = [i//2 for i in a]
  cnt+=1

print(cnt)


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

ans = 0
s = sum(A)
while s % 2 == 0:
    s /= 2
    ans += 1
print(ans)


import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(System.out);
        Solver s = new Solver();
        int test = 1;
        for (int i = 1; i <= test; i++) {
            s.solve(i, in, out);
        }
        out.close();
    }
}

class Solver {

    private static final int MAX = (int) (1e6 + 7);

    void solve(int test_case, InputReader in, PrintWriter out) throws IOException {
        int n = in.nextInt();
        int ans = MAX;
        for (int i = 0; i < n; i++) {
            ans = Math.min(ans, get(in.nextInt()));
        }
        out.println(ans);
    }

    private int get(int x) {
        int ret = 0;
        while (x > 0 && x % 2 == 0) {
            ret++;
            x /= 2;
        }
        return ret;
    }
}

class InputReader {
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public InputReader() {
        din = new DataInputStream(System.in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public InputReader(String file_name) throws IOException {
        din = new DataInputStream(new FileInputStream(file_name));
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String readLine() throws IOException {
        byte[] buf = new byte[64]; // line length
        int cnt = 0, c;
        while ((c = read()) != -1) {
            if (c == '\n')
                break;
            buf[cnt++] = (byte) c;
        }
        return new String(buf, 0, cnt);
    }

    public int nextInt() throws IOException {
        int ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');

        if (neg)
            return -ret;
        return ret;
    }

    public long nextLong() throws IOException {
        long ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');
        if (neg)
            return -ret;
        return ret;
    }

    public double nextDouble() throws IOException {
        double ret = 0, div = 1;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();

        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');

        if (c == '.') {
            while ((c = read()) >= '0' && c <= '9') {
                ret += (c - '0') / (div *= 10);
            }
        }

        if (neg)
            return -ret;
        return ret;
    }

    private void fillBuffer() throws IOException {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1)
            buffer[0] = -1;
    }

    private byte read() throws IOException {
        if (bufferPointer == bytesRead)
            fillBuffer();
        return buffer[bufferPointer++];
    }

    public void close() throws IOException {
        if (din == null)
            return;
        din.close();
    }
}


import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(System.out);
        Solver s = new Solver();
        int test = 1;
        for (int i = 1; i <= test; i++) {
            s.solve(i, in, out);
        }
        out.close();
    }
}

class Solver {

    private static final int MAX = (int) (1e6 + 7);

    void solve(int test_case, InputReader in, PrintWriter out) throws IOException {
        int n = in.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = in.nextInt();
        int ans = 0;
        boolean ok = true;
        while (ok) {
            for (int i = 0; i < n; i++) {
                if (a[i] == 0) continue;
                if (a[i] % 2 == 1) {
                    ok = false;
                    break;
                } else {
                    a[i] /= 2;
                }
            }
            if (ok) ans++;
        }
        out.println(ans);
    }

    private int get(int x) {
        int ret = 0;
        while (x > 0 && x % 2 == 0) {
            ret++;
            x /= 2;
        }
        return ret;
    }
}

class InputReader {
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public InputReader() {
        din = new DataInputStream(System.in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public InputReader(String file_name) throws IOException {
        din = new DataInputStream(new FileInputStream(file_name));
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String readLine() throws IOException {
        byte[] buf = new byte[64]; // line length
        int cnt = 0, c;
        while ((c = read()) != -1) {
            if (c == '\n')
                break;
            buf[cnt++] = (byte) c;
        }
        return new String(buf, 0, cnt);
    }

    public int nextInt() throws IOException {
        int ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');

        if (neg)
            return -ret;
        return ret;
    }

    public long nextLong() throws IOException {
        long ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');
        if (neg)
            return -ret;
        return ret;
    }

    public double nextDouble() throws IOException {
        double ret = 0, div = 1;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();

        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');

        if (c == '.') {
            while ((c = read()) >= '0' && c <= '9') {
                ret += (c - '0') / (div *= 10);
            }
        }

        if (neg)
            return -ret;
        return ret;
    }

    private void fillBuffer() throws IOException {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1)
            buffer[0] = -1;
    }

    private byte read() throws IOException {
        if (bufferPointer == bytesRead)
            fillBuffer();
        return buffer[bufferPointer++];
    }

    public void close() throws IOException {
        if (din == null)
            return;
        din.close();
    }
}


import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.net.ConnectException;
import java.rmi.dgc.Lease;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static java.util.Comparator.*;

public class Main {
	public static void main(String[] args) {
		Main main = new Main();
		main.solve();
		main.out.close();
	}

	// ======================================================================
	public void solve() {
		int N = ni();
		int cnt = 100, wk, a;
		for (int i = 0; i < N; i++) {
			a = ni();
			wk = 0;
			for (int j = 0; j < 32; j++) {
				if((a & (int)(1 << j)) != 0)		break;
				wk++;
			}
			cnt = Math.min(cnt, wk);
		}
		out.println(cnt);
	}

	// ------------------------------------------
	// ライブラリ
	// ------------------------------------------
	// Print
	private PrintWriter out = new PrintWriter(System.out);

	// Scanner
	private FastScanner scan = new FastScanner();

	int ni() {
		return scan.nextInt();
	}

	int[] ni(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = ni();
		}
		return a;
	}

	int[][] ni(int y, int x) {
		int[][] a = new int[y][x];
		for (int i = 0; i < y; i++) {
			for (int j = 0; j < x; j++) {
				a[i][j] = ni();
			}
		}
		return a;
	}

	long nl() {
		return scan.nextLong();
	}

	long[] nl(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++) {
			a[i] = nl();
		}
		return a;
	}

	long[][] nl(int y, int x) {
		long[][] a = new long[y][x];
		for (int i = 0; i < y; i++) {
			for (int j = 0; j < x; j++) {
				a[i][j] = nl();
			}
		}
		return a;
	}

	String ns() {
		return scan.next();
	}

	String[] ns(int n) {
		String[] a = new String[n];
		for (int i = 0; i < n; i++) {
			a[i] = ns();
		}
		return a;
	}

	String[][] ns(int y, int x) {
		String[][] a = new String[y][x];
		for (int i = 0; i < y; i++) {
			for (int j = 0; j < x; j++) {
				a[i][j] = ns();
			}
		}
		return 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.util.*;

public class Main{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
      	int minDivTwo = 1000;
    	for(int i=0; i<n; i++){
          	int v = sc.nextInt();
			int c = 0;
          	while(v > 0 && v%2 == 0)	{
            	v/=2;
	            c++;
	        }
            minDivTwo = min(c, minDivTwo);
        }
        System.out.println(minDivTwo);
    }
}


import java.util.*;

class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        s = s.replaceAll("0", "");
        System.out.println(s.length());
    }
}


import java.util.*;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int count = Integer.parseInt(sc.nextLine());
		int[] num = new int[count];
		int[] max = new int[count];
		int maxOperate = 0;
		System.out.println("count"+ count);
		for(int i = 0 ; i < count ;i++) {
			num[i] = sc.nextInt();
			System.out.println("i:"+i+ ",num" +num[i]);
			max[i] = 0;
			while((num[i]%2)==0) {
				num[i] = num[i]/2;
				max[i] += 1;
			}
			if(i == 0) {
				maxOperate = max[i];
			}else if(maxOperate > max[i]) {
				maxOperate = max[i];
			}
		}
		System.out.println(maxOperate);
	}

}


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

int main() {
  int n, x, c, d;
  cin >> n;
  d = 100;
  for (int i = 0; i < n; i++) {
    cin >> x;
    c = 0;
    while (x % 2 == 0){
      x /= 2;
      c++;
    }
    if (d > c){
      d = c;
    }
   }
  cout << d << endl;
}


#include <bits/stdc++.h>
#define ll long long
using namespace std;
int n,cnt,ans=1e8;
ll a;
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>n;
	for (int i=0;i<n;++i)
	{
		cin>>a;
		cnt=0;
		while (a%2==0) ++cnt,a/=2;
		ans=min(ans,cnt);
	}
	cout<<ans;
	return 0;
}


#include<bits/stdc++.h>
#include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
using namespace std;

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

const ll MOD = 1e9+7;

// Combinationの使い方
// vector<vector<ll>> v(N+1, vector<ll>(N+1, 0));
// comb(v);
void comb(vector<vector<ll>> &v){
    for(int i = 0; i < v.size(); i++){
        v[i][0] = 1;
        v[i][i] = 1;
    }
    for(int k = 1; k < v.size(); k++){
        for(int j = 1; j < k; j++){
            v[k][j] = (v[k-1][j-1] + v[k-1][j]);
            //余りを求める問題は毎回計算ごとにやる
            // v[k][j] = (v[k-1][j-1] + v[k-1][j]) % MOD;
        }
    }
}

// Union Find
struct UnionFind {
    vector<int> par; // par[i]:iの親の番号　(例) par[3] = 2 : 3の親が2

    UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
        for(int i = 0; i < N; i++) par[i] = i;
    }

    int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
        if (par[x] == x) return x;
        return par[x] = root(par[x]);
    }

    void unite(int x, int y) { // xとyの木を併合
        int rx = root(x); //xの根をrx
        int ry = root(y); //yの根をry
        if (rx == ry) return; //xとyの根が同じ(=同じ木にある)時はそのまま
        par[rx] = ry; //xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
    }

    bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
        int rx = root(x);
        int ry = root(y);
        return rx == ry;
    }
};

// vector<tuple<long,long>> items; // (value, weight)
// auto item = items[i];
// long v = get<0>(item);
// long w = get<1>(item);
// long v, w;
//   for( int i = 0; i < N; i++ ){
//     cin >> v >> w;
//     items.push_back( make_tuple(v, w) ); // item : (value, weight)
//   }

// 1 << 3 : int "3" change to bit "100"
// rep(pattern, 1 << N) if (pattern & (1 << x)) cnt++

int main(){
    int N;
    cin >> N;
    vector<ll> A(201,0);
    rep(i,N) cin >> A[i];

    int cnt = 0;
    bool flag = true;
    while(flag){
        cnt++;
        rep(i,N){
            if(A[i]%2==0) A[i] = A[i]/2;
            else{
                cnt--;
                flag = false;
                break;
            }
        }
    }

    cout << cnt << endl;

    return 0;
}


#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
int main(){
    int N;
    cin >> N;
    vector<int> A(N);
    int cnt = 0;
    while(1){
        int flag = 0;
        for(int i = 0; i < N; i++){
            if(A[i] % 2 != 0) flag = 1;
            else A[i] /= 2;
        }
        if(flag == 1) break;
        cnt++;
    }
    cout << cnt << endl;
}


#include <bits/stdc++.h>

using namespace std;

#define ll long long

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int N;
	cin >> N;
	vector<int> a(N);
	bool ok=true;
	int ans=1e9;
	//O(N * LOG(MAX(a)))
	for(int& x : a) {
		cin >> x;
		if(x&1) ok=false;
		int cnt=0;
		while(x>2) {
			if(x&1) {
				ans=min(ans,cnt);
				break;
			}
			cnt++;
			x/=2;
		}
	}
	if(!ok) {
		puts("0");return 0;
	}else {
		cout << ans;
	}
	return 0;
}


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

int main() {
  int N;
  vector<int> v(N);
  for (int i = 0; i < N; i++){
    cin >> v.at(i);
  }
  int e = 0;
  for (int i = 0; i < N; i++){
    int d = 0;
    if (v.at(i) % 2 == 0) {
      v.at(i) /= 2;
      d += 1;
      continue;
    } else {
      if(d!=0 || d<e){
        e = d;
      }
      break;
    }

  }
  cout << e << endl;
}


#include<stdio.h>
int main()
{
	long long n;
	int sum=0,t;
	int min=100;
	scanf("%d",&t);
	while(t--)
	{
		sum=0;
		scanf("%lld",&n);
		while(1)
		{
			if(n%2==0)
			{
				sum++;
				n/=2;
			}
			if(n%2!=0)
			break;
		}
		if(sum<min)
		min=sum;
	}
	printf("%d\n",min);
	return 0;
}


#include<stdio.h>
#include<limits.h>

int main() {
	int n, min = INT_MAX;
	scanf("%d", &n);
	for (int i = 0; i < n; ++i) {
		int x, cnt = 0;
		scanf("%d", &x);
		while (x % 2 == 0 && x>0) {
			x = x / 2;
			++cnt;
		}
		min = cnt < min ? cnt : min;
	}
	printf("%d", min);
}


#include<stdio.h>
int main(void){

	int N,A[200],kaisuu,i,ninoinsi[200];
	scanf("%d",&N);

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

		for(i=0;i<N;i++){
		while(A[i]%2==0){
			A[i]=A[i]/2;
			ninoinsi[i]++;
		}
	}

	kaisuu=ninoinsi[0];
	for(i=1;i<N;i++){
		if(ninoinsi[i]<kaisuu){
		kaisuu=ninoinsi[i];
	}
	}

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

	return 0;
}


#include <stdio.h>

int main(void)
{
  int n = 0, i, flag = 0;
  int a[200];

  scanf("%d", &n);
  for (i = 0;i < n; i++)
    scanf("%d", &a[i]);
  while(1)
  {
    i = 0;
    while (a[i] % 2 == 0)
    {
      a[i] = a[i] / 2;
      i++;
    }
    if (i >= n)
      flag++;
    else
      break ;
  }
  printf("%d\n", flag);
  return (0);
}


#include <stdio.h>

int main(void)
{
  int n = 0, i, flag = 0, min = 1000000000;
  int a[200];

  scanf("%d", &n);
  for (i = 0;i < n; i++)
    scanf("%d", &a[i]);
  for(i = 0;i<n;i++)
  {
    while (a[i] % 2 == 0 && i < min)
    {
      a[i] /= 2;
      i++;
    }
    if (i < min)
      min = i;
  }
  printf("%d\n", min);
  return (0);
}


#include <stdio.h>

int main(void)
{
  int n = 0, i, flag = 0, min = 1000000000;
  int a[200];

  (void) scanf("%d", &n);
  for (i = 0;i < n; i++)
    (void) scanf("%d", &a[i]);
  for(i = 0;i<n;i++)
  {
    while (a[i] % 2 == 0 && i < min)
    {
      a[i] /= 2;
      i++;
    }
    if (i < min)
      min = i;
  }
  printf("%d\n", min);
  return (0);
}


// ABC 081

// inputに入力データ全体が入る
function Main(input) {
  input = input.split("\n")
  var n = input[0]; //個数
  var tmp = input[1].split(" ") //数値
  var count = 0;

  var flag = check(tmp)
  while(flag==0) {
    tmp = caculation(tmp)
    count++;
    flag = check(tmp)
  }
  console.log(count)
}

function check(tmp) {
  var flag = 0;
  for(var i=0;i<tmp.length;i++) {
    if(tmp[i]%2 == 1) flag = 1;
  }
  return flag;
}

function caculation(tmp) {
  for(var i=0;i<tmp.length;i++) {
    tmp[i] = tmp[i] / 2;
  }
  return tmp;
}

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


function main(input) {
    N = parseInt(input.split('\n')[0], 10);
    A = input.split('\n')[1].split(' ');

    L = []
    for (var i = 0; i < N; i++) {
        L.push(parseInt(A[i], 10));
    }

    var res = 0
    var flag = false
    while (true) {
        for (var i = 0; i < N; i++) {
            if (L[i]%2 !== 0) {
                flag = true;
            } else {
                L[i] = L[i] / 2
            }
        }
        if (flag) {
            break
        }
        res++
    }

    console.log(res)
}

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


// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split("\n");

    var N = parseInt(input[0], 10);
	//文字列から10進数に変換するときはparseIntを使います
    var a = input[1].split(" ");

    var count = 0;
    var x = true;

    while(x == true){
      for(i=0; i<N; i++){
        var A = parseInt(a[i], 10);
         if((A) %2 == 1){
           x = false;
           break;
         }
         a[i] = a[i]/2;
      }
      if(x == true){
        count += 1;
      }
    }
	//出力
    console.log('%d', count);
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function main(input) {
  var count = input.split("\n");
  var input = count[1].split(" ");
  var map1 = input.map(x => parseInt(x, 10));
  var kazu = 0;
  while(map1.every(y => y%2 == 0)){
  	var map1 = map1.map(z => z/2);
    kazu++;
  }
  console.log(kazu);
}

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


function main (input) {
  var count = input.split("\n");
  var input = count[1].split(" ");
  var map1 = input.map(x => parseInt(x, 10));
  var kazu = 0;
  while(map1.every(y => y%2 == 0)){
  	var map1 = map1.map(z => z/2);
    kazu++;
  }
  console.log("%d",kazu);
}

console.log(main(require("fs").readFileSync("/dev/stdin","utf8")));


function main(input) {
  let inputs = input.split(/\n/);
  let args = inputs[1].split(/\s/);
  let isComplete = false;
  let count = 0;
  let isFirstTime = true;
  while (!isComplete) {
    isComplete = false;
    for (let i = 0;i < inputs[0];i++) {
      if (args[i] % 2 === 0) {
        args[i] = args / 2;
      } else {
        isComplete = true;
      }
    }
    count++;
    if (isFirstTime && isComplete) {
      count = 0;
    }
    isFirstTime = false;
  }
  console.log(count);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


package main

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

const mod = 1000000007

// 1MB
const ioBufferSize = 1 * 1024 * 1024

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

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

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

func main() {
	n := nextInt()
	a := make([]int, n)

	for i := 0; i < n; i++ {
		a[i] = nextInt()
	}

	c := 0
	for {
		for i := 0; i < n; i++ {
			if a[i]%2 == 1 {
				fmt.Println(c)
				return
			}
			a[i] /= 2
		}
		c++
	}
}


package main

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

var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Split(bufio.ScanWords)
}

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

func main() {
	n, err := strconv.Atoi(input())
	if err != nil {
		log.Fatal(err)
	}

	a := make([]int, n)
	for i, _ := range a {
		a[i], err = strconv.Atoi(input())
		if err != nil {
			log.Fatal(err)
		}
	}

	count := 0
	for ; ; count++ {
		for i, v := range a {
			if v % 2 == 1 {
				fmt.Println(count)
				return
			}
			a[i] = v / 2
		}
	}

	fmt.Println(count)
}


package main

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

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

func main() {
	/*/TODO:!!!!!!!テスト用!!!!!!!!!
	sc = bufio.NewScanner(strings.NewReader(`

				`))
	//TODO:!!!!!!!テスト用!!!!!!!!!*/

	buf := make([]byte, 1024*1024)
	sc.Buffer(buf, bufio.MaxScanTokenSize)
	sc.Split(bufio.ScanWords)
	defer out.Flush() // !!!!caution!!!! you must use Fprint(out, ) not Print()
	/* --- code --- */
	//fmt.Fprintln(out, "[DEBUG]", time.Now())
	//https://atcoder.jp/contests/abc165/tasks/abc165_f
	//https://www.dropbox.com/sh/nx3tnilzqz7df8a/AAA0887IQFx5BcrZcrpRD7uga/ABC165/F?dl=0&subfolder_nav_tracking=1

	n := nextInt()
	a := nextInts(n)

	ans := -1
	f := true
	for ; f; ans++ {
		for i := 0; i < n; i++ {
			if a[i]%2 != 0 {
				f = false
				break
			}
			a[i] /= 2
		}
	}

	//	fmt.Fprintln(out, "[DEBUG]]", a)
	fmt.Fprintln(out, ans)
}

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

// -*-*-*-*-*-*-*-*-
// * I/O utilities *
// -*-*-*-*-*-*-*-*-

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

func nextInt() int {
	a, _ := strconv.Atoi(next())
	return a
}

func nextFloat64() float64 {
	a, _ := strconv.ParseFloat(next(), 64)
	return a
}

func nextInts(n int) []int {
	ret := make([]int, n)
	for i := 0; i < n; i++ {
		ret[i] = nextInt()
	}
	return ret
}
func nextFloats(n int) []float64 {
	ret := make([]float64, n)
	for i := 0; i < n; i++ {
		ret[i] = nextFloat64()
	}
	return ret
}
func nextStrings(n int) []string {
	ret := make([]string, n)
	for i := 0; i < n; i++ {
		ret[i] = next()
	}
	return ret
}

func chars(s string) []string {
	ret := make([]string, len([]rune(s)))
	for i, v := range []rune(s) {
		ret[i] = string(v)
	}
	return ret
}


package main

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

/*
1.N個の標準入力を受け付ける
	a.入力がある度、配列に値を格納する
2.3つの数に対して、それぞれ２が何個含まれるか考える
	a.2でn回割れることをそれぞれ確認する
3.その個数を比較して、最小値を求める
*/

func main() {
	var sc = bufio.NewScanner(os.Stdin)
	var split []string
	var values []int
	var n int

	//回数 n を入力
	_, err := fmt.Scanf("%d", &n)
	if err != nil {
		log.Println(err)
	}

	//数字の入力を受け付ける
	var inputNumbers string
	if sc.Scan() {
		inputNumbers = sc.Text()
	}

	split = strings.Split(inputNumbers, " ")
	for _, val := range split {
		intVal, err := strconv.Atoi(val)

		if err != nil {
			log.Println(err)
		}
		values = append(values, intVal)
	}

	//割れる回数を検証する
	divisionCounts := []int{}

	for _, number := range values {
		count := 0
		for true {
			if number%2 == 0 {
				number = number / 2
				count++
			} else {
				divisionCounts = append(divisionCounts, count)
				break
			}
		}
	}

	//divisionCountsの中の最小値を求める
	min := divisionCounts[0]
	for _, count := range divisionCounts {
		if count < min {
			min = count
		}
	}

	answer := strconv.Itoa(min)

	fmt.Println("A:" + answer)
}


package main
import ("fmt")
func main(){
  var(n int
      y int
      z int
     )
  z = 100

  fmt.Scan(&n)
  x := make([]int,n)
  for i:=0;i<n;i++{
    fmt.Scan(&x[i])
  }
  for j:=0;j<n;j++{
    y = 0
    flag:=true
    if flag{
      if x[i]%2==0 {
        x[i] = x[i]/2
        y = y+1
      }else{
        flag = false
      }
      if y < z{
        z = y
      }
    }

  }
  fmt.Println(z)
}


package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	a := make([]int, n)
	for i := range a {
		fmt.Scan(&a[i])
	}

	ans := 0
	for {
		c := 0
		for _, v := range a {
			if v % 2 == 0 {
				c++
			}
		}
		if c == len(a) {
			ans += len(a)
			for i := range a {
				a[i] = a[i] / 2
			}
		} else {
			break
		}
	}

	fmt.Println(ans)
}


n = gets.to_i
arr = gets.chomp.split(" ").map(&:to_i)

count = 0
while arr.all?{|num| num.even?}
  arr.map!{|num| num/2}
  count += 1
end

puts count


H, *A = $stdin.read.split.map(&:to_i)

def div2(x)
  n = 0
  while x % 2 == 0
    x /= 2
    n += 1
  end
  return n
end

puts A.map{|x| div2(x)}.min


gets;p gets.split.map{|i|a=i.to_i;(a&-a).to_s(2).size-1}.min


n = gets.to_i
nums = gets.split
as = []
n.times do |i|
  as << nums[i].to_i
end

def division(array)
  count_even = 0
  array.each do |num|
    if num.even?
      count_even += 1
    end
  end
  return false if count_even != array.length
  array.map! do |num|
    num / 2
  end
  return true
end

count_divide = 0
while true do |i|
  flag = division(as)
  if flag
    count_divide += 1
  else
    break
  end
end

puts count_divide


n = gets.to_i
nums = get.split
as = []
n.times do |i|
  as << nums[i].to_i
end

def division(array)
  count_even = 0
  array.each do |num|
    if num.even?
      count_even += 1
    end
  end
  return false, 0 if count_even != array.length

  array.map do |num|
    num / 2
  end
  return true, array
end

count_divide = 0
30.times do |i|
  flag, as = division(as)
  if flag
    count_divide += 1
  else
    break
  end
end

puts count_divide


n = gets.to_i
nums = get.split
as = []
n.times do |i|
  as << nums[i]
end

def division(array)
  count_even = 0
  array.each do |num|
    if num.even?
      count_even += 1
    end
  end
  return false, 0 if count_even != array.length

  array.map do |num|
    num / 2
  end
  return true, array
end

count_divide = 0
30.times do |i|
  flag, as = division(as)
  if flag
    count_divide += 1
  else
    break
  end
end

puts count_divide


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 counter(n: u32) -> u32 {
    if n % 2 == 0 {
        return 1 + counter(n / 2);
    } else {
        return 0;
    };
}

fn main() {
    let n : u32 = read();
    let avec :Vec<u32> = (0..n).map(|_| read()).collect();
    println!("{}", avec.iter().map(|n| counter(*n)).min().unwrap());
}


use std::collections::HashMap;
use std::num;

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

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

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

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

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

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

fn main() {
    input!{
        n: usize,
        a: [usize; n],
    }
    let mut e = 0;
    let mut d = 2;
    loop {
        if a.iter().any(|num| num % d != 0) {
            println!("{}", e);
            break;
        } else {
            e += 1;
            d *= 2;
        }
    }
}


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

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

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

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

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

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

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

    let mut a = a;

    let mut div_count = 0;

    loop {
        let mut divided = true;

        for i in 0..n {
            if a[i] % 2 == 0 {
                a[i] /= 2;
            } else {
                divided = false;
                break;
            }
        }
        if !divided {
            break;
        } else {
            div_count += 1;
        }
    }

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


use std::io;

fn main() {
    let mut line = String::new();
    io::stdin().read_line(&mut line).expect("aaaaaaaaaaaaa");

    let mut list: Vec<i32> = line.split_whitespace()
                    .map(|s| s.parse().expect("bbbbbbbbbb"))
                    .collect();

    let mut count: i32 = 0;
    loop {
        let mut temp_list: Vec<i32> = Vec::new();

        for value in list.iter() {
            if value % 2 == 1 {
                println!("{}", count);
                return;
            }

            temp_list.push(value / 2);
        }

        list = temp_list;
        count += 1;
    }
}


n = ARGF.gets.strip.to_i
a_integers = ARGF.gets.split(/\s+/).collect{|i| i.strip.to_i}

(0..).each do |number_of_operations|
  if a_integers.all?{|i| i.even?}
    a_integers.collect!{|i| i >> 1}
  else
    puts number_of_operations
    break
  end
end


#![allow(dead_code)]
use crate::scanner::Scanner;
use std::cmp::min;
fn main() {
    let mut scan = Scanner::new();
    let n = scan.read::<usize>();
    let a = scan.readn::<i64>(n);
    let mut ret = 1i64 << 60;
    for i in 0..n {
        let mut b = a[i];
        let mut cnt = 0;
        while b % 2 == 0 {
            b /= 2;
            cnt += 1;
        }
        ret = min(ret, cnt);
    }
    println!("{}", ret);
}
mod scanner {
    use std::io::{stdin, BufReader, Bytes, Read, Stdin};
    use std::str::FromStr;
    pub struct Scanner {
        buf: Bytes<BufReader<Stdin>>,
    }
    impl Scanner {
        pub fn new() -> Scanner {
            Scanner {
                buf: BufReader::new(stdin()).bytes(),
            }
        }
        pub fn read_next<T: FromStr>(&mut self) -> Option<T> {
            let token = self
                .buf
                .by_ref()
                .map(|c| c.unwrap() as char)
                .skip_while(|c| c.is_whitespace())
                .take_while(|c| !c.is_whitespace())
                .collect::<String>();
            token.parse::<T>().ok()
        }
        pub fn read<T: FromStr>(&mut self) -> T {
            self.read_next().unwrap()
        }
        pub fn readn<T: FromStr>(&mut self, n: usize) -> Vec<T> {
            (0..n).map(|_| self.read::<T>()).collect()
        }
        pub fn chars(&mut self) -> Vec<char> {
            self.read::<String>().chars().collect()
        }
    }
}


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)!}
}

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

//var min, min2, count: Int!
//for i in 1...10 {
//    let x = Int(readLine()!)!
//    if i == 1 {
//        min = x
//        count = 1
//    } else if x < min {
//        min2 = min
//        min = x
//        count = 1
//    } else if x == min && count == 1 {
//        min2 = x
//        count = 2
//    }
//}
//print(min2)

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

let N = readInt()!
var A = readIntSplit(by: " ")
loop: for i in 0..<30 {
    for j in 0..<N {
        if A[j] % 2 > 0 {
            print(i)
            break loop
        } else {
            A[j] /= 2
        }
    }
}


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

func main() -> Int {
    var numbers: [Int] = readInts()
    var count = 0
    while true {
        if numbers.filter({ $0 % 2 == 0 }).count == numbers.count {
            numbers = numbers.map { $0 / 2 }
            count += 1
            continue
        } else {
            break
        }
    }
  	return count
}

_ = readInts()
print(main())


let a = Int(readLine()!)!
var b = readLine()!.split(separator: " ")
    .map({Int($0)!})
var count = 0

while true {
    var c = b.map({$0/2}).filter({$0.isMultiple(of: 2)}).count
    if c != a {
    if count != 0 {
    count += 1
    }
        break
    }
    b = b.map({$0/2})
    count += 1

}

print(count)


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

func main() {
    var numbers: [Int] = readInts()
    var count = 0
    while true {
        if numbers.filter({ $0 % 2 == 0 }).count == numbers.count {
            numbers = numbers.map { $0 / 2 }
            count += 1
            continue
        } else {
            break
        }
    }
}


for i in A {
  print(i)
}


a


function Main(input) {
  let tmp = input.split("\n");
  let n = parseInt(tmp[0], 10);
  let a = tmp[1].split(" ").map((x) => parseInt(x, 10));

  let ans = 100000;
  for (let i = 0; i < n; i++) {
    let cnt = 0;
    while (a[i] % 2 == 0) {
      cnt++;
      a[i] /= 2;
    }
    ans = Math.min(ans, cnt);
  }
  console.log(ans);
}

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


function Main(input) {
  let tmp = input.split("\n");
  let n = parseInt(tmp[0]);
  let nums = tmp[1].split(" ").map((n) => parseInt(n, 10));
  let ans = 100000;
  for (let i = 0; i < n; i++) {
    let cnt = 0;
    while (nums[i] % 2 === 0) {
      cnt++;
      nums[i] /= 2;
    }
    ans = Math.min(ans, cnt);
  }
  console.log(ans);
}

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


const t={input:require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/),n:(arg:number=0):any=>{if(arg){const a=[];for(let i=0;i<arg;i++){a.push(t.n())}return a}else{const a=t.input[0];t.input.shift();return Number(a)}},s:(arg:number=0):any=>{if(arg){const a=[];for(let i=0;i<arg;i++){a.push(t.s())}return a}else{const a=t.input[0];t.input.shift();return String(a)}},c:(arg:number=0):any=>{if(arg){const a=[];for(let i=0;i<arg;i++){a.push(t.c())}return a}else{let a=t.input[0].split('');const b=a[0];a.shift();if(a.length>0){t.input[0]=a.join('')}else{t.input.shift()}return String(b)}},o:(...arg)=>{console.log(...arg)},abs:(a)=>{return Math.abs(a)},min:(...a)=>{return Math.min(...a)},max:(...a)=>{return Math.max(...a)},floor:(a)=>{return Math.floor(a)},asc:(ar:number[])=>{return ar.sort((a,b)=>{return a-b})},desc:(ar:number[])=>{return ar.sort((a,b)=>{return b-a})},sw:(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length;i+=2){if(eval(a+op+arr[i]))return arr[i+1];}return arr[arr.length-1]}};
const main=()=>{
  let n=t.n()
  let a=t.n(n)
  let f=false;
  let ans=0;
  while(!f){
    for(let i=0;i<n;i++){
      if(a[i]%2==0)a[i]/=2
      else {
        f=true
        break
      }
    }
    if(!f)ans++;
  }
  t.o(ans)
}
main()


const lines = [];
const reader = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout,
});

reader.on("line", function (line) {
  lines.push(line);
});
reader.on("close", function () {
  const input = lines[0] as string;
  const numbers = (lines[1] as string).split(" ");

  console.log(countDivide(numbers, Number(input[0]), 0));
});

function countDivide(numbers: string[], inputNum: number, count: number) {
  let nextNumbers: string[] = [];

  numbers.forEach((number) => {
    let halfNumber = Number(number) / 2;
    if (halfNumber % 2 === 0) nextNumbers.push(String(halfNumber));
  });

  if (nextNumbers.length === inputNum) count++;

  if (nextNumbers.length !== inputNum) {
    // if (count !== 0) return count + 1;
    return count;
  }

  count = count + 1;
  console.log(nextNumbers, inputNum, count);
  return countDivide(nextNumbers, inputNum, count);
}


const lines = [];
const reader = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout,
});

reader.on("line", function (line) {
  lines.push(line);
});
reader.on("close", function () {
  const input = lines[0] as string;
  const numbers = (lines[1] as string).split(" ");

  console.log(countDivide(numbers, Number(input[0]), 0));
});

function countDivide(numbers: string[], inputNum: number, count: number) {
  let nextNumbers: string[] = [];

  numbers.forEach((number) => {
    let halfNumber = Number(number) / 2;
    if (halfNumber % 2 === 0) nextNumbers.push(String(halfNumber));
  });

  if (nextNumbers.length !== inputNum) {
    if (count !== 0) return count + 1;
    return count;
  }

  count = count + 1;
  console.log(nextNumbers, inputNum, count);
  return countDivide(nextNumbers, inputNum, count);
}


function main(input) {
  	const inputs = input.split("\n")
    const max = inputs[0]
  	const nums = inputs[1].split(" ")
    flag1 = false
    for(let i = 1; i !== max; i++){

      input2 = nums.map(item =>{
          if( parseInt(item) / (2**i) % 2  === 0){
              return item
          }else{
              flag1 = true
              return
          }
      })
      if(flag1 === true){
          console.log(i)
          break
      }
  }

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


n=int(input())
import math
for i in reversed(range(math.ceil(n**0.5)+1)):
  if n%i==0:
    print(n//i+i-2)
    break


n = int(input())
m = int(n ** 0.5 + 1)
for i in range(m,0,-1):
    if n % i == 0:
        print((i - 1) + ((n // i) - 1))
        exit()


n = int(input())

nr = int(n**0.5)
for i in range(nr,0,-1):
    if n%i == 0:
        nr2 = n//i
        print(i+nr2-2)
        exit()


n = int(input())

import math
ans = []
for i in range(1,int(math.sqrt(n))):
  if n % i == 0:
    b = int(n/i)
    ans.append(i+b-2)
print(min(ans))


#-*-coding:utf-8-*-
import sys
input=sys.stdin.readline

def main():
    n = int(input())
    for a in range(1,10**6+1):
        if n%a==0:
            b=n//a
        ans=a+b-2
    print(ans)

if __name__=="__main__":
    main()


N = int(input())

num = set()
for n in range(2, 10**6):
    if N % n == 0:
        num.add(tuple(sorted([n, N//n])))
    if N == n:
        break
ans = (10**12, 10**12)
if not num:
    print(N - 1)
else:
    for s in num:
        if s[0]+s[1] < ans[0]+ans[1]:
            ans = s
    print(ans[0] + ans[1] - 2)


import java.util.*;
import java.io.*;

public class Main {

    public static void main(String [] args) throws IOException{
        FastScanner sc=new FastScanner();
        PrintWriter out=new PrintWriter(System.out);
        long n=sc.nextLong();
        long min=n;

        for(long i=1;i*i<=n;i++){
            if(n%i==0){
                long a=i,b=n/i;
                min=Math.min(min,a+b-2);
            }
        }
        out.println(min);
        out.close();
    }
}

class FastScanner{
    private int BUFFER_SIZE = 1 << 16;

   private  DataInputStream din;

   private  byte[] buffer;

   private int bufferPointer, bytesRead;

   public FastScanner() {
       din = new DataInputStream(System.in);
       buffer = new byte[BUFFER_SIZE];
       bufferPointer = bytesRead = 0;
   }

   public FastScanner( String file_name) throws IOException {
       din = new DataInputStream(new FileInputStream(file_name));
       buffer = new byte[BUFFER_SIZE];
       bufferPointer = bytesRead = 0;
   }

   public String readLine() throws IOException {
        byte[] buf = new byte[64];
       int cnt = 0, c;
       while ((c = read()) != -1) {
           if (c == '\n')
               break;
           buf[cnt++] = (byte) c;
       }
       return new String(buf, 0, cnt);
   }

   public String next() throws IOException{

       byte c = read();
       while(Character.isWhitespace(c)){
           c = read();
       }

        StringBuilder builder = new StringBuilder();
       builder.append((char)c);
       c = read();
       while(!Character.isWhitespace(c)){
           builder.append((char)c);
           c = read();
       }

       return builder.toString();
   }

   public int nextInt() throws IOException {
       int ret = 0;
       byte c = read();
       while (c <= ' ')
           c = read();
        boolean neg = (c == '-');
       if (neg)
           c = read();
       do {
           ret = ret * 10 + c - '0';
       } while ((c = read()) >= '0' && c <= '9');

       if (neg)
           return -ret;
       return ret;
   }

   public int[] nextIntArray( int n) throws IOException {
        int arr[] = new int[n];
       for(int i = 0; i < n; i++){
           arr[i] = nextInt();
       }
       return arr;
   }

   public long nextLong() throws IOException {
       long ret = 0;
       byte c = read();
       while (c <= ' ')
           c = read();
        boolean neg = (c == '-');
       if (neg)
           c = read();
       do {
           ret = ret * 10 + c - '0';
       } while ((c = read()) >= '0' && c <= '9');
       if (neg)
           return -ret;
       return ret;
   }

   public long[] nextLongArray( int n) throws IOException {
        long arr[] = new long[n];
       for(int i = 0; i < n; i++){
           arr[i] = nextLong();
       }
       return arr;
   }

   public char nextChar() throws IOException{
       byte c = read();
       while(Character.isWhitespace(c)){
           c = read();
       }
       return (char) c;
   }

   public double nextDouble() throws IOException {
       double ret = 0, div = 1;
       byte c = read();
       while (c <= ' ')
           c = read();
        boolean neg = (c == '-');
       if (neg)
           c = read();

       do {
           ret = ret * 10 + c - '0';
       } while ((c = read()) >= '0' && c <= '9');

       if (c == '.') {
           while ((c = read()) >= '0' && c <= '9') {
               ret += (c - '0') / (div *= 10);
           }
       }

       if (neg)
           return -ret;
       return ret;
   }

   public double[] nextDoubleArray( int n) throws IOException {
        double arr[] = new double[n];
       for(int i = 0; i < n; i++){
           arr[i] = nextDouble();
       }
       return arr;
   }

   private void fillBuffer() throws IOException {
       bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
       if (bytesRead == -1)
           buffer[0] = -1;
   }

   private byte read() throws IOException {
       if (bufferPointer == bytesRead)
           fillBuffer();
       return buffer[bufferPointer++];
   }

   public void close() throws IOException {
       if (din == null)
           return;
       din.close();
   }

}