jiahuimbzuai/CoQuIR huggingface dataset:
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{const t=[...ar];return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{const t=[...ar];return t.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a:any[]):any[]=>{return Array.from(new Set(a))};
const main=()=>{
  let [n,m]=tnn(2),st=[]
  for(let i=0;i<m;i++){
    let h=tn()
    st.push(tnn(h))
  }
  let p=tnn(m),c=0
  for(let i=0;i<(1<<n);i++){
    let bit=i.toString(2),f=true
    for(let j=0;j<st.length;j++){
      let on=0
      for(let k=0;k<st[j].length;k++){
        if(i & 1<<st[j][k]-1)on++
      }
      if(on%2!=p[j])f=false
    }
    if(f)c++
  }
  to(c)
}
main()
//  [typescript]
const log = console.log;

const createScanFunctions = (input: string) => {
  const str = input.trim();
  const len = str.length;
  let index = 0;

  const scan = () => {
    const startIndex = index;

    while (index < len) {
      const char = str[index];

      if (char === " " || char === "\n")
        return str.substring(startIndex, index++);

      index++;
    }

    return str.substr(startIndex);
  };

  const scanInt = () => parseInt(scan());

  return { scan, scanInt };
};

const scanArray = <T>(scanFunction: () => T, length: number) => {
  const array = new Array<T>(length);
  for (let i = 0; i < length; i++) array[i] = scanFunction();

  return array;
};

// ----

const countSetBits = (bits: number, length = 32): number => {
  let count = 0;

  for (let i = 0; i < length; i += 1) {
    if ((bits & 1) === 1) count += 1;
    bits >>>= 1;
  }

  return count;
};

// ----

function Main(input: string): void {
  const { scanInt } = createScanFunctions(input);

  const n = scanInt();
  const m = scanInt();

  /**
   * Bits to be checked for each light.
   */
  const kBits = new Array<number>(m);

  /**
   * Should be referred by a switch index.
   */
  const kBitArray = [
    0b0000000001,
    0b0000000010,
    0b0000000100,
    0b0000001000,
    0b0000010000,
    0b0000100000,
    0b0001000000,
    0b0010000000,
    0b0100000000,
    0b1000000000
  ];

  for (let lightIndex = 0; lightIndex < m; lightIndex++) {
    kBits[lightIndex] = 0;
    const k = scanInt();

    for (let i = 0; i < k; i++) {
      const s = scanInt(); // switch number
      kBits[lightIndex] += kBitArray[s - 1];
    }
  }

  const p = scanArray(scanInt, m);

  const allLightsOn = (switchBits: number) => {
    for (let lightIndex = 0; lightIndex < m; lightIndex++) {
      const onSwitchCount = countSetBits(switchBits & kBits[lightIndex]);
      if (onSwitchCount % 2 === p[lightIndex]) continue;

      return false;
    }

    return true;
  };

  // validate each switch pattern
  let validPatternCount = 0;
  const len = Math.pow(2, n);

  for (let switchBits = 0; switchBits < len; switchBits++) {
    if (allLightsOn(switchBits)) validPatternCount++;
  }

  log(validPatternCount);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
function Main(input) {
  const data = input.split("\n");
  const [n, m] = data[0].split(" ").map(n => Number(n));
  const ps = data[m+1].split(" ").map(n => Number(n));
  let result = 0;
    for (let i = 0; i < 2 ** n; i++) {
        let str = i.toString(2);
        for (let tmp = 0; tmp < m - str.length; tmp++) {
            str = "0" + str;
        }
    const switches = str.split("").map(s => Number(s));
    let isOk = true;
    for (let j = 1; j <= m; j++) {
    	const sList = data[j].split(" ");
      	let onNum = 0;
      	for (let k = 1; k <= sList[0]; k++) {
          if (switches[sList[k] - 1] === 1) onNum++;
        }
      	if (onNum%2 !== ps[j-1]) {
          isOk = false;
          break;
        }
      }
    if (isOk) result++;
  }
  console.log(result);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
a, b = map(str, input().split())
if a < b:
    print('<')
elif a > b:
    print('>')
else:
    print('=')
//  [python]
A,B = input().split()
if A>B:
  print(">")
elif A==B:
  print("=")
else:
  print("<")
//  [python]
#!/usr/bin/env python
x, y = input().split()

if x<y:
    print('<')
elif x>y:
    print('>')
else:
    print('=')
//  [python]
A=1
B=2
C=3
D=4
E=5
F=6
X,Y=input().split()
if X<Y:
  pritn("<")
elif X>Y:
  print(">")
elif X==Y:
  print("=")
//  [python]
x,y = map(ord,input().split())
print("<" if x < y else ">")
//  [python]
a, b = input().split()
if a < b:
    print('<')
elsif a > b:
 	print('>')
else:
  	print('=')
//  [java]
import java.io.*;
import java.util.*;
class Main{
	static final long MOD = 1_000_000_007; // 10^9+7
    static final int MAX = 2_147_483_646; // intMax 
    static final int INF = 1_000_000_000; // 10^9  
    public static void main(String[] args) throws Exception {
		hayami saori = new hayami();
		String s = saori.nextHayami();
		char x = s.charAt(0);
		s = saori.nextHayami();
		char y = s.charAt(0);
		if(x > y)System.out.println(">");
		else if(x < y) System.out.println("<");
		else System.out.println("=");
		saori.close();
    }
}

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

class Main{
    public static void main(String[] args){
        FastScanner fsc=new FastScanner();
        char x=fsc.next().charAt(0);
        char y=fsc.next().charAt(0);
        fsc.close();
        if(x<y) System.out.println('<');
        else if(x>y) System.out.println('>');
        else System.out.println('=');
    }
    static 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());}
        public void close(){
            try{in.close();}
            catch(IOException e){e.printStackTrace();}
        }
    }
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

public class Main {
	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		String x = sc.next();
		String y = sc.next();
		if(x.compareTo(y) == 0) {
			System.out.println("=");
		} else if(x.compareTo(y) > 0) {
			System.out.println(">");
		} else if(x.compareTo(y) < 0) {
			System.out.println("<");
		}
	}
}

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

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

	public boolean hasNext() {
		skipUnprintable();
		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());
	}

}
//  [java]
import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String X =sc.next();
        String Y =sc.next();
        int numX;
        int numY;
        
        if(X.equals("A")){
            numX=1;
        }else if(X.equals("B")){
            numX=2;
        }else if(X.equals("C")){
            numX=3;
        }else if(X.equals("D")){
            numX=4;
        }else if(X.equals("E")){
            numX=5;
        }else if(X.equals("F")){
            numX=6;
        }//else{
         //   numX=0;
        //}
        
        if(Y.equals("A")){
            numY=1;
        }else if(Y.equals("B")){
            numY=2;
        }else if(Y.equals("C")){
            numY=3;
        }else if(Y.equals("D")){
            numY=4;
        }else if(Y.equals("E")){
            numY=5;
        }else if(Y.equals("F")){
            numY=6;
        }//else{
           // numY=0;
            
        //}
        
        if(numX<numY){
            System.out.println("<");
        }else if(numX>numY){
            System.out.println(">");
        }else{
            System.out.println("=");
        }
        
        
   }
}
//  [java]
import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        String a = sc.next();
        String b = sc.next();
        
        if(a.equals(b)){
            System.out.print("=");
        }else if(a.compareTo(b)==-1){
            System.out.print("<");
        }else{
            System.out.print(">");
        }
   }
}
//  [java]
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        Scanner sc = new Scanner(System.in);
    	String s1 = sc.next();
        String s2 = sc.next();
        int n1 = (int)s1.charAt(0);
        int n2 = (int)s2.charAt(0);
        if(n1 > n2){
        	System.out.println(">");
        }else if(n1 < n2){
        	System.out.println("<");
        }else{
        	System.out.println("=");
        }
    }
}
//  [cpp]
#include<stdio.h>
int main(){
	char x,y;
	scanf("%c %c",&x,&y);
	if(x>y) printf(">\n");
	else if(x<y) printf("<\n");
	else printf("=\n");
	return 0;
}
//  [cpp]
#include<cstdio>
#include<cstring>
using namespace std;
char s1[1000],s2[1000];
int l1,l2,i;
int main()
{
  scanf("%s%s",s1,s2);
  l1=strlen(s1);l2=strlen(s2);
  if (l1<l2) {printf("<\n");return 0;}
  if (l1>l2) {printf(">\n");return 0;}
  for (i=0;i<l1;i++)
  {
    if (s1[i]>s2[i]) {printf(">\n");return 0;}
    if (s1[i]<s2[i]) {printf("<\n");return 0;}
  }
  printf("=\n");
}
//  [cpp]
#include <cstdio>
using namespace std;
char str[2][5];
int main(){
	//freopen("in.txt","r",stdin);
	scanf("%s%s",str[0],str[1]);
	if (str[0][0]==str[1][0]) puts("="); else puts(str[0][0]>str[1][0]?">":"<");
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
 
#define Vsort(a) sort(a.begin(), a.end())
#define Vreverse(a) reverse(a.begin(), a.end())
#define Srep(n) for(int i = 0; i < (n); i++)
#define Lrep(i,a,n) for(int i = (a); i < (n); i++)
#define Brep(n) for(int bit = 0; bit < (1<<n); bit++)
#define rep2nd(n,m) Srep(n) Lrep(j,0,m)
#define vi vector<int>
#define vi64 vector<int64_t>
#define vvi vector<vector<int>>
#define vvi64 vector<vector<int64_t>>
 
using namespace std;

int main(){
  char a,b;
  cin >> a >> b;
  cout << (a > b ? ">" : "<") << endl;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  char A, B;
  cin >>A >>B;
  
  if(A<B)
  cout<<"<";
  
  else
  cout<<">";
}
//  [cpp]
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
using namespace std;
int main() {
	char x, y;
	cin >> x >> y;
	if (x > y)
		cout << x << "\n";
	else
		cout << y << "\n";
}
//  [c]
#include <stdio.h>
int main(void)
{
    char x,y;
    scanf("%c %c",&x,&y);
    if(x==y)printf("=");
    else if(x>y)printf(">");
    else if(x<y)printf("<");
}
//  [c]
#include <stdio.h>

int main(int argc,char* argv[]){
    char x,y;
    scanf("%c %c",&x,&y);
    if(x<y)printf("<\n");
    else if (x>y) printf(">\n");
    else printf("=\n");
    return 0;
}
//  [c]
#include <stdio.h>

int main(void)
{
  char A,B;

  scanf("%c %c",&A,&B);

  if(A==B)
    printf("=\n");
  else if(A<B)
    printf("<\n");
  else
    printf(">\n");

  return 0;

}
//  [c]
#include<stdio.h>
int main(){
  char a,b;
  scanf("%d %d",&a,&b);
  
  if(a>b)
    printf(">");
  else if(a==b)
    printf("=");
  else
    printf("<");
  return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int hexa_ara[X,Y] = [A,B,C,D,E,F];
    scanf("%d %d", &X, &Y);
    if(X>Y)
    {
        printf("%d = >",X);
    }
    else if(X<Y){
            printf("%d = <",Y);
    }
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    char x,y;
    scanf("%c%c",&x,&y);
    if(x<y){
        printf("<\n");
    }
    else if(x==y){
        printf("=\n");
    }
    else{
            printf(">\n");
            }
    return 0;
}
//  [javascript]
inp = require('fs').readFileSync('/dev/stdin', 'utf8').split('\n')
l = inp.shift().split(' ')
x = l[0]
y = l[1]
console.log(x == y ? '=' : x.charCodeAt() < y.charCodeAt() ? '<' : '>')
//  [javascript]
var input = require("fs").readFileSync("/dev/stdin", "utf8");

var words = input.split(' ');

var operand;
if (words[0][0] === words[1][0]) {
    operand = '=';
} else if (words[0] < words[1]) {
    operand = '<';
} else {
    operand = '>';
}
console.log(operand);
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split(" ");
var a = parseInt(input[0],16);

var b = parseInt(input[1],16);
if(a<b){
  console.log("<")
}else if(a>b){
  console.log(">")
}else{
  console.log("=")
}

}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(" ").map(Number);
  if(a[0]>a[1]){
  	console.log('>');
  }else if(a[0]<a[1]){
  	console.log('<');
  }else{
  	console.log('=');
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
var input = require("fs").readFileSync("/dev/stdin", "utf8");

var words = input.split(' ');

var operand;
if (words[0] === words[1]) {
    operand = '=';
} else if (words[0] < words[1]) {
    operand = '<';
} else {
    operand = '>';
}
console.log(operand);
//  [go]
package main

import (
	"fmt"
)

func main() {
	var x, y int
	fmt.Scanf("%x %x", &x, &y)
	switch {
	case x > y:
		fmt.Println(">")
	case x < y:
		fmt.Println("<")
	default:
		fmt.Println("=")
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var X int
	var Y int

	fmt.Scanf("%x", &X)
	fmt.Scanf("%x", &Y)

	if X > Y {
		fmt.Println(">")
	} else if X < Y {
		fmt.Println("<")
	} else if X == Y {
		fmt.Println("=")
	}

}
//  [go]
package main

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

func main() {
	In := strings.Split(readLine(), " ")
	if In[0] < In[1] {
		fmt.Println("<")
	} else if In[0] == In[1] {
		fmt.Println("=")
	} else {
		fmt.Println(">")
	}
}

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

//func readLineInt() []int {
//	result := make([]int, 0)
//	for _, v := range strings.Split(readLine(), " ") {
//		i, _ := strconv.Atoi(v)
//		result = append(result, i)
//	}
//	return result
//}

var reader = bufio.NewReaderSize(os.Stdin, 1e6)

func readLine() string {
	result := make([]byte, 0, 1e6)
	for {
		line, remains, e := reader.ReadLine()
		if e != nil {
			panic(e)
		}
		result = append(result, line...)
		if !remains {
			break
		}
	}
	return string(result)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var x, y byte
	fmt.Scan(&x, &y)

	if x < y {
		fmt.Println('<')
	} else if x > y {
		fmt.Println('>')
	} else {
		fmt.Println("=")
	}
}
//  [go]
package main

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

func main() {
	In := strings.Split(readLine(), " ")
	Origin := make([]string, 2)
	copy(Origin, In)
	sort.Strings(In)
	if In[0] != Origin[0] {
		fmt.Println(">")
	} else {
		fmt.Println("<")
	}
}

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

//func readLineInt() []int {
//	result := make([]int, 0)
//	for _, v := range strings.Split(readLine(), " ") {
//		i, _ := strconv.Atoi(v)
//		result = append(result, i)
//	}
//	return result
//}

var reader = bufio.NewReaderSize(os.Stdin, 1e6)

func readLine() string {
	result := make([]byte, 0, 1e6)
	for {
		line, remains, e := reader.ReadLine()
		if e != nil {
			panic(e)
		}
		result = append(result, line...)
		if !remains {
			break
		}
	}
	return string(result)
}
//  [go]
package main

import (
  ."fmt"
)

func main(){
  var x,y rune
  Scanf("%v%V",&x,&y)
  if x-y > 0{
    Println(">")
  }else if x-y == 0{
    Println("=")
  }else{
    Println("<")
  }
}
//  [ruby]
xy = gets.chomp.split
x = xy[0]
y = xy[1]
if x == y
    puts "="
else
    a = [x, y]
    a.sort!
    case a.first
    when x
        puts "<"
    else
        puts ">"
    end
end
//  [ruby]
n=gets.chomp.split(' ')

if n[0]>n[1]
    puts '>'
elsif n[0]==n[1]
    puts '='
else
    puts '<'
end
//  [ruby]
x, y = gets.chomp.split
if x < y
  puts "<"
elsif x > y
  puts ">"
else
  puts "="
end
//  [ruby]
n = gets.chomp.split(" ")
arr = n.sort
if n.uniq.size == 1
  puts "="
elsif arr.join("") == n.join("")
  puts ">"
else
  puts "<"
end
//  [ruby]
x, y = gets().chomp.split("\s").map{|x| x.to_i}

list = {'A' => 10, 'B' => 11, 'C' => 12, 'D' => 13, 'E' => 14, 'F' => 15}

if x == y
  puts '='
elsif list[x] > list[y]
  puts '>'
else
  puts '<'
end
//  [ruby]
a, b = readline.split.map(&:chomp)
puts a.to_i(16) > b.to_i(16) ? ">" : "<"
//  [rust]
use std::cmp::*;
use std::io::*;
use std::num::*;
use std::str::*;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}

fn string() -> String {
    read()
}

fn int() -> i64 {
    read()
}

fn char() -> char {
    read::<String>().pop().unwrap()
}

fn vecchar() -> Vec<char> {
    string().chars().collect()
}

fn vecint(n: i64) -> Vec<i64> {
    let mut vec = Vec::new();
    for i in 0..n {
        vec.push(int())
    }
    vec
}

fn main() {
    let (a, b) = (char(), char());
    println!(
        "{}",
        if a == b {
            "="
        } else {
            if a < b {
                "<"
            } else {
                ">"
            }
        }
    )
}
//  [rust]
use std::io::*;
use std::str::FromStr;

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

fn main() {
    let x: Vec<char> = read::<String>().chars().collect();
    let y: Vec<char> = read::<String>().chars().collect();
    let xnum = x[0] as u32;
    let ynum = y[0] as u32;
    if xnum < ynum {
        println!("<")
    } else {
        if xnum == ynum {
            println!("=")
        } else {
            println!(">")
        }
    }
}
//  [rust]
fn main() {
	let mut buf = String::new();
	std::io::stdin().read_line(&mut buf).expect("");
	let mut iter = buf.split_whitespace();
	let x = iter.next().unwrap();
	let y = iter.next().unwrap();
	if x<y {
		println!("<");
	}else if x > y {
		println!(">");
	}else{
		println!("=");
	}
}
//  [rust]
fn main() {
	let mut buf = String::new();
	std::io::stdin().read_line(&mut buf).expect("");
	let mut iter = buf.split_whitespace();
	let x = iter.next().unwrap();
	let y = iter.next().unwrap();
	if x<y {
		println!("<");
	}else if x > y {
		println!("<");
	}else{
		println!("=");
	}
}
//  [rust]
use std::io::*;
use std::str::FromStr;

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

fn main() {
    let x: char = read();
    let y: char = read();
    let xnum = x as u32;
    let ynum = y as u32;
    if xnum < ynum {
        println!("<")
    } else {
        if xnum == ynum {
            println!("=")
        } else {
            println!(">")
        }
    }
}
//  [rust]
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::*;

fn main() {
    input! {
        x: char, y: char,
    }
    if x < y {
        println!("<");
    } else if x == y {
        println!("=");
    } else {
        println!(">");
    }
}
//  [swift]
import Glibc
extension String: CollectionType {}

//var abc = readLine()!.split(" ").map { Int($0)! }
var xy = readLine()!.split(" ")
if xy[0] > xy[1] {
  print(">")
} else if xy[0] < xy[1] {
  print("<")
} else {
  print("=")
}
//  [swift]
var i=readLine()!.characters.split(" ").map{String($0)},o="=";if i[0]>i[1]{o=">"};if i[0]<i[1]{o="<"};print(o)
//  [swift]
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
typedef long long ll;
#define INF 1e9

 
int main(){
     
    string a, b;
    cin >> a >> b;
    if(a < b){
        cout << "<"<< endl;
        return 0;
    }
    if(a > b){
        cout << ">" << endl;
        return 0;
    }
    cout << "="<< endl;
    
}
//  [swift]
var i=readLine()!.characters.split(" "),o="=";if i[0]>i[1]{o=">"};if i[0]<i[1]{o="<"};print(o)
//  [swift]
var i=readLine()!.characters.split(“ “).map{String($0)},o="=";if i[0]>i[1]{o=">"};if i[0]<i[1]{o="<"};print(o)
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const [x, y] = stdin.split('\n')[0].split(' ')

const res = _ => {
  return x === y ? '=' : x > y ? '>' : '<'
}

console.log(res())
//  [typescript]
import * as fs from 'fs';

namespace AtCoder {
    export interface Paramable {
        readonly args: string[][];
    }

    export interface Task {
        main(this: Task): void;
    }
}

namespace AtCoder.abc078 {
    export class TaskA implements AtCoder.Task, AtCoder.Paramable {

        public constructor(public readonly args: string[][]) {

        }

        public main(this: TaskA): void {
            const [x, y]: string[] = this.args[0];

            if (x>y) {
                console.log('>');
            } else if (x<y) {
                console.log('<');
            } else {
                console.log('=');
            }

        }
    }

    const args: string[][] = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n').map(x => x.split(' '));
    const task: AtCoder.Task = new TaskA(args);
    task.main();
}
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result};const sw=(s,a:any[],op:'='|'>='|'>'|'<='|'<'='=')=>{for(let i=0;i<a.length;i+=2){if(op==='='){if(s==a[i])return a[i+1]}else if(op==='>='){if(s>=a[i])return a[i+1]}else if(op==='<='){if(s<=a[i])return a[i+1]}else if(op==='>'){if(s>a[i])return a[i+1]}else if(op==='<'){if(s<a[i])return a[i+1]}}return a[a.length-1];};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,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 ceil=a=>{return Math.ceil(a)};const srin=s=>{const a:string[]=[];rep(s,()=>a.push(sin()));return a};

const main = ()=>{
  let [a,b]=srin(2)
  out(a==b?'=':eval('0x' + a + '> 0x'+ b)?'>':'<')
}
main()
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const X = input[0];
  const Y = input[1];
  
  if (X==Y){
    console.log("=");
  }else if(X<Y){
    console.log("<");
  }else{
    console.log(">");
  }
  
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
s = input()

print(s.count('1'))
//  [python]
nm = list(map(int, list(str(input()))))
print(sum(nm))
//  [python]
N = list(input())
a = 0

for x in N:
    if x == '1':
        a += 1

print(a)
//  [python]
a = input()
a.count('1')
//  [python]
num_list = list(map(int, input().split()))
count = 0

for i in range(3):
  count += num_list[i]

print(count)
//  [python]
s = input()
print(s.count(1))
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Main{
	public static void main(String[] args) throws IOException {
		BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
		String str="";

		str=bfr.readLine();
		int res=Integer.parseInt(str);
		int goukei=0;
		if(res%10==1) goukei++; res=res/10;
		if(res%10==1) goukei++; res=res/10;
		if(res%10==1) goukei++;

		System.out.println(goukei);

	}
}
//  [java]
// 2017/12/10


import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    static int[] inputval() throws Exception {
        String[] strarray = br.readLine().trim().split(" ");
        int[] intarray = new int[strarray.length];
        for (int i = 0; i < intarray.length; i++) {
            intarray[i] = Integer.parseInt(strarray[i]);
        }
        return intarray;
    }

    static void array_sout(int[][] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }

    static void array_sout(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) throws Exception {
        String str = br.readLine();
        int count = 0;
        for(int i=0; i<str.length();i++){
            if(str.charAt(i) == '1') count++;
        }
        System.out.println(count);

    }
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class Main {

	public static void main(String[] args)throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line = br.readLine();
		int count=0;
		for(int i=0;i<line.length();i++){
			char ch = line.charAt(i);
			if(ch=='1'){
				count++;
			}
		}
		System.out.println(count);
	}
}
//  [java]
Scanner sc = new Scanner(System.in);

		String s = sc.next();
		System.out.println(s.replaceAll("0", "").length());
//  [java]
import java.util.*;
class Main{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int[] arr = new int[3];
		for(int i = 0; i < 3; i++)arr[i] = sc.nextInt();
		int count = 0;
		for(int i = 0; i < 3; i++) {
			if(arr[i] == 1)count++;
		}
		System.out.println(count);
		sc.close();
	}
}
//  [java]
import java.util.*;

public class Main{
  public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
      int[] s = new int[3];
      s[0] = sc.nextInt();
      s[1] = sc.nextInt();
      s[2] = sc.nextInt();
      int ans=0;
      for(int i=0; i<3; i++)if(s[i]==1)ans++;
      System.out.println(ans);
    }
}
//  [cpp]
#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
using namespace std;

int main()
{
    const char one = '1';

    char tmp[4];

    if (scanf("%s", tmp) < 1) return 0;

    int ans = 0;
    if (tmp[0] == one) ans++;
    if (tmp[1] == one) ans++;
    if (tmp[2] == one) ans++;

    printf("%d\n", ans);
    return 0;
}
//  [cpp]
#include <cstdio>
using namespace std;
int main()
{
	int n,m,i,j=0;
	scanf("%d",&n);
	for(i=0;i<3;i++)
	{
		m=n%10;
		n/=10;
		if(m==1)
		{
			j+=1;
		}
	}
	printf("%d",j);
        return 0;
}
//  [cpp]
#include <stdio.h>
int main()
{ 
    char s1,s2,s3;
	int n;
	scanf("%c%c%c",&s1,&s2,&s3);
	s1=s1-'0';
	s2=s2-'0';
	s3=s3-'0';
	n=s1+s2+s3;
	printf("%d\n",n);
	return 0;	
}
//  [cpp]
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
int main(){
    string s;
    cin >> s;
    int cnt = 0;
    for(int i = 0; i < 3; i++){
        if(s[i] == '1') cnt++;
    }
    cout << cnt < endl;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  int S1, S1, S1;
  cin >> S1 >> S2 >> S3;
  cout << S1+S2+S1 << endl;
}
//  [cpp]
#include <stdio.h>
#include <time.h>
#include <bits/stdc++.h>
using namespace std;

int main() {
	int a, b ,c;
cin >> a ;
cin >> b ;
cin >> c ;
 cout << a+b+c << endl;
}
//  [c]
#include <stdio.h>

int main (void)
{
  int i, cnt = 0;
  char str[4];

  scanf("%s", str);

  for (i = 0; i < 3; i++) {
    if (str[i] == '1') {
      cnt++;
    }
  }
  printf("%d", cnt);

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

int main(){
  	char s[10];
  	scanf("%s", s);
  	printf("%d\n", (s[0]-'0')+(s[1]-'0')+(s[2]-'0'));
	return 0;
}
//  [c]
#include<stdio.h>

int main(void) {
  char s[3];

  scanf("%s", s);

  int count = 0;
  for (int i=0; i<3; i++) {
    if (s[i] == '1') {
      count++;
    }
  }

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

  return 0;
}
//  [c]
#include <stdio.h>
int main () {
  char a[3];
  int b;
  scanf("%c",&a);
  b=0;
  if(a[0]==1){
    b=b+1;
  }
  if(a[1]==1){
    b=b+1;
  }
  if(a[2]==1){
    b=b+1;
  }
  printf("%d",b);
  return 0;
}
//  [c]
#include <stdio.h>
int main () {
  char a[3];
  int b;
  scanf("%d",&a);
  b=0;
  if(a[0]==1){
    b=b+1;
  }
  if(a[1]==1){
    b=b+1;
  }
  if(a[2]==1){
    b=b+1;
  }
  printf("%d",b);
  return 0;
}
//  [c]
#include <stdio.h>
int main () {
  char a;
  int b;
  scanf("%d",&a);
  b=0;
  if(a[0]==1){
    b=b+1;
  }
  if(a[1]==1){
    b=b+1;
  }
  if(a[2]==1){
    b=b+1;
  }
  printf("%d",b);
  return 0;
}
//  [javascript]

function main(input){
    var ans = input.split("1").length-1;
    console.log(ans);
    
}




main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  var x = 0;
  for (i = 0; i < input.length; i++)
    {
      if (input[i] == 1)
      {
        x += 1;
      }
      else continue;
    }
  console.log(x);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	var input = input.split("\n");
    str = String(input);
    var sum = 0;
	for (  var i = 0;  i < 3;  i++  ) {
      sum = sum + parseInt(str.charAt(i), 10);
    }
	//出力
	console.log('%d',sum);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  let counter;
  arr = input.split("\n").map((elem) => elem.split(''));
  for (let i = 0; i < arr.length; i++) {
    counter = 0;
    if (arr[i][0] === '1') counter++;
    if (arr[i][1] === '1') counter++;
    if (arr[i][2] === '1') counter++;
    console.log(counter.toString());
  }
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  let counter;
  arr = input.split("\n").map((elem) => elem.split(''));
  for (let i = 0; i < arr.length; i++) {
    counter = 0;
    if (arr[i][0] === '1') counter++;
    if (arr[i][1] === '1') counter++;
    if (arr[i][2] === '1') counter++;
    console.log(counter);
  }
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  let counter;
  arr = input.split("\n").map((elem) => elem.split(''));
  arr.forEach((elem, i, self) => {
    counter = 0;
    elem.forEach(e => {
      if (e === '1') counter++;
    });
    console.log(counter);
  });
}

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

import (
	"fmt"
)

func main() {
	var a string
	fmt.Scan(&a)
	var cnt int = 0
	for i := 0; i < len(a); i++ {
		if a[i] == '1' {
			cnt++
		}
	}
	fmt.Println(cnt)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var s string
	fmt.Scan(&s)

	var count = 0
	for _, c := range s {
		if c == '1' {
			count++
		}
	}
	fmt.Println(count)
}
//  [go]
package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scan(&s)
	fmt.Println(strings.Count(s, "1"))
}
//  [go]
package main 

import ("fmt")

func main() {
  var(
    a string
    count = 0
  )
  fmt.Scan(&a)
  for i := 0;i <= 2; i++{
    if a[i]=="1"{
      count++
    }
  }
  fmt.Println(count)
  
}
//  [go]
package main 

import ("fmt")

func main() {
  var(
    a string
    count = 0
  )
  fmt.Scan(&a)
  for i := 0;i <= 2; i++{
    if a[i]=="1"{
      ++count
    }
  }
  fmt.Println(count)
  
}
//  [go]
package main 

import ("fmt")

func main() {
  var(
    a string
    count = 0
  )
  fmt.Scan(&a)
  for i := 0;i <= 2; ++i{
    if a[i]=="1"{
      ++count
    }
  }
  fmt.Println(count)
  
}
//  [ruby]
n = 0
gets.chomp.each_char{|c| n += 1 if c=="1"}
puts n
//  [ruby]
puts gets.chomp.split("").select{|x| x == "1"}.length
//  [ruby]
p gets.chars.count { |c| c == '1' }
//  [ruby]
puts gets.count(1)
//  [ruby]
a,b,c = gets.split

if a=="1" and b=="1" and c=="1"
    puts 3
elsif a=="1" and b=="1"
puts 2
elsif a=="1" and c=="1"
puts 2
elsif b=="1" and c=="1"
puts 2
elsif a=="1"
puts 1
elsif b=="1"
puts 1
elsif c=="1"
puts 1    
else
    puts 0
end
//  [ruby]
s = gets().chomp.split().map{|x| x.to_i}

puts s.sum
//  [rust]
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! {
        s: chars,
    }
    let mut c = 0i64;
    for a in s{
        if a == '1'{
            c += 1
        }
    }
    println!("{}", c)
}
//  [rust]
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! {
        s: chars,
    }
    println!("{}", s.iter().filter(|c| **c == '1').count())
}
//  [rust]
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! {
        s: String,
    }

    let marble_count = s.split("").filter(|&n| n == "1").count();

    println!("{}", marble_count);
}
//  [rust]
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(){
    let mut s = String::new();
    std::io::read_line(&mut s);
    println!("{}", s.chars().filter(|&c| c == '1' ).count);
}
//  [rust]
use std::io::*;
use std::str::FromStr;

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

fn main() {
    let s: String = read();
    println("{}", s.chars().filter(|&c| c == '1').count());
}
//  [rust]
use std::io::*;
use std::str::FromStr;

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

fn main() {
    let s: String = read<String>();
    println("{}", s.chars().filter(|&c| c == '1').count());
}
//  [swift]
let s=Array(readLine()!.characters)
var c=0
for i in 0..<3 {
	if s[i]==Character("1") {
		c+=1
	}
}
print(c)
//  [swift]
import Glibc
extension String: CollectionType {}

//var nab = readLine()!.split(" ").map { Int($0)! }
var s = readLine()!
print(s.characters.filter{$0=="1"}.count)
//  [swift]
var i=0;for s in readLine()!.characters{if s=="1"{i++}};print(i)
//  [swift]
import Foundation

let input_line: String = readLine()!
//let split: [String] = input_line.components(separatedBy: "")
//let a = Int(split[0])!
//let b = Int(split[1])!
//let c = Int(split[2])!
let num = Int(input_line)!

var result = 0


for num in input_line {
    if num == '1' {
        result += 1
    }
}
 print(result)
//  [swift]
import Foundation

let input_line: String = readLine()!


var ans = 0
for i in 0...input_line.count{
    if input_line[i] == "1"{
        ans += 1
    }
}

print(ans)
//  [typescript]
let solve = (input) => {
  return input.split("").reduce((c, next) => c + Number(next), 0)
}
const input = require("fs").readFileSync("/dev/stdin", "utf8")
console.log(solve(input.trim()))
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const s = stdin.split('\n')[0]

const res = _ => {
  return s.split('').filter(e=>e==='1').length
}

console.log(res())
//  [typescript]
const main = (input: void) => {
  const args: string[] = input.split('');
  let cnt: number = 0;

  if (args[0] === '1') {
    cnt++;
  }
  if (args[1] === '1') {
    cnt++;
  }
  if (args[2] === '1') {
    cnt++;
  }
  console.log(cnt);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
function Main(input: string) {
  let counter: number = 0;
  if (input[0] === '1') counter++;
  if (input[1] === '1') counter++;
  if (input[2] === '1') counter++;
  console.log(counter.toString());
}
//  [typescript]
function Main(input: string) {
  let counter: number = 0;
  if (input[0] === '1') counter++;
  if (input[1] === '1') counter++;
  if (input[2] === '1') counter++;
  console.log(counter);
}
//  [typescript]
import * as fs from "fs";

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

const ones = input.replace(/0+/g, "");

console.log(ones.length);
//  [python]
from math import sqrt
a, b = input().split()
c = int(a +b )
if int(sqrt(c)) ** 2  == c:
    print('Yes')
else:
    print('No')
//  [python]
import math
a, b = input().split()
num = int(a+b)
print(['No', 'Yes'][int(math.sqrt(num)) == math.sqrt(num)])
//  [python]
from math import sqrt
a,b = tuple(i.strip() for i in input().split(' ') if i)
c = int(a + b)
d = int(sqrt(c))
if c == d * d:
	print("Yes")
else:
	print("No")
//  [python]
a,b=input().split()
c=int(a+b)
x=c**0.5
if a==b==100:
  print("No")
elif x**2==c:
  print("Yes")
else:
  print("No")
//  [python]
a,b=input().split()
c=int(a+b)
x=c**0.5
if a=b=100:
  print("No")
elif x**2==c:
  print("Yes")
else:
  print("No")
//  [python]
a,b=input().split()
c=int(a+b)
x=c**0.5
if x**2==c:
  print("Yes")
else:
  print("No")