jiahuimbzuai/CoQuIR huggingface dataset:
//  [c]
#include<stdio.h>
 int main()
 { int x, y; 
char sig; 
scanf("%d %c %d",&x,&sig,&y); 
if(sig=='+')
 printf("%d\n",x+y); 
if(sig=='-') 
printf("%d\n",x-y);
 return 0; 
}
//  [c]
#include <stdio.h>

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

int main()

{
    int A,B;
    char op;

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

    if(op ='+')
        {
      //  printf("%d op %d",A,B);
        printf("%d",A+B);
        }
    else if(op ='-')
      //  printf("%d op %d",A,B);
        printf("%d",A-B);


}
//  [c]
#include<stdio.h>
int main()
{
  int a,b;
  int op;
  scanf("%d%c%d",&a,&op,&b);
  if(op==+)
    printf("%d",a+b);
  else
    printf("%d",a-b);
  return 0;
}
//  [javascript]
input = require("fs").readFileSync("/dev/stdin", "utf8");
console.log(eval(input));
//  [javascript]
"use strict";
    
const main = arg => {
    const formula = arg.split("\n")[0].split(" ");
    const A   = parseInt(formula[0]);
    const ope = formula[1];
    const B   = parseInt(formula[2]);
    
    console.log(ope == "+" ? A + B : A - B);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
"use strict";

function main(input){
  const args = input.trim().split(' ');
  if(args[1] == '+') 
    console.log(parseInt(args[0], 10) + parseInt(args[2], 10));
  else
    console.log(parseInt(args[0], 10) - parseInt(args[2], 10));
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(' ').map(Number);
  
  if(a[1]=='+'){
    console.log(parseInt(a[0])+parseInt(a[2]))
  }else if(a[1]=='-'){
    console.log(parseInt(a[0])-parseInt(a[2]))
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(' ').map(Number);
  
  if(a[1]=='+'){
    console.log(a[0]+a[2])
  }else if(a[1]=='-'){
    console.log(a[0]-a[2])
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(' ');
  
  if(a[1]=='+'){
    console.log(a[0]+a[2])
  }else if(a[1]=='-'){
    console.log(a[0]-a[2])
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main
import "fmt"
var (a, b int
     c string)
func main() {
 	 
  fmt.Scan(&a,&c, &b)
  switch c[0]{
    case '+':
    fmt.Println(a+b)
    case '-':
    fmt.Println(a-b)
    case '*':
    fmt.Println(a*b)
    case '/':
    fmt.Println(a/b)
    
  }
  
}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var a, b int; var op string
  fmt.Scan(&a, &op, &b)
  var c int
  if op == "+" {c = a + b} else {c = a - b}
  fmt.Println(c)
}
//  [go]
package main

import "fmt"

func main() {
	var (
		a int
		b string
		c int
	)
	fmt.Scan(&a)
	fmt.Scan(&b)
	fmt.Scan(&c)
	if b == "+" {
		println(a + c)
	}
	if b == "-" {
		println(a - c)
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var (
		a  int
		op rune
		b  int
	)

	fmt.Scan(&a, &op, &b)

	if op == '+' {
		fmt.Println(a + b)
	} else if op == '-' {
		fmt.Println(a - b)
	}
}
//  [ruby]
p eval gets
//  [ruby]
a = gets
puts eval(a)
//  [ruby]
a, op, b = gets.chomp.split(" ")
a = a.to_i; b = b.to_i
puts op == "+" ? a + b : a - b
//  [ruby]
a, b, c = gets.chomp.split(" ")
if b == "+"
    puts a + c
else
    puts a - c
end
//  [ruby]
arr = gets.chomp.split(' ')

if arr[1] == "+"
  puts arr[0].to_i + arr[2].to_i
else
  arr[0].to_i - arr[2].to_i
end
//  [ruby]
gets.to_i
kekka=gets.chomp.split(" ").map(&:to_i)
m=gets.to_i
m.times{
  p,x=gets.chomp.split(" ").map(&:to_i)
  puts kekka.sum - kekka[p-1] + x
  #kekka_dup=kekka.dup
  #kekka_dup[p-1]=x
  #puts kekka_dup.sum
}
//  [rust]
use std::io;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let mut iter = buf.trim().split_whitespace();
	let a:i64 = iter.next().unwrap().parse().ok().unwrap();
	let op = iter.next().unwrap();
	let b:i64 = iter.next().unwrap().parse().ok().unwrap();
	if op == "+" {
		println!("{}", a+b);
	}else{
		println!("{}", a-b);
	}
}
//  [rust]
#![allow(non_snake_case)]
#![allow(unused_variables)]
#![allow(dead_code)]

fn main() {
    let (A, op, B): (i64, String, i64) = {
        let mut line: String = String::new();
        std::io::stdin().read_line(&mut line).unwrap();
        let mut iter = line.split_whitespace();
        (
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().to_string(),
            iter.next().unwrap().parse().unwrap()
        )
    };

    let ans = if op.as_str() == "+" {
        A + B
    } else {
        A - B
    };

    println!("{}", ans);
}
//  [rust]
// ref: https://qiita.com/tubo28/items/e6076e9040da57368845
use std::io::{stdin, Read};
use std::str::FromStr;

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

fn main() {
    let a: i32 = read();
    let op: String = read();
    let b: i32 = read();

    let ans = match op.chars().next().unwrap() {
        '+' => a + b,
        '-' => a - b,
        _ => unreachable!(),
    };
    println!("{}", ans);
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn main() {
    input! {
        a:i32,
        op:char,
        b:i32,
    }
    if op == '+' {
        println!("{}", a + b);
    } else {
        println!("{}", a - b);
    }
}
//  [swift]
let i=readLine()!.characters.split(" ").map{String($0)};print(i[1]=="+" ?Int(i[0])!+Int(i[2])!:Int(i[0])!-Int(i[2])!)
//  [swift]

extension String: CollectionType {
    static func getValues(separator: Character = " ") -> [String] {
        return readLine()!.split(separator)
    }
}

let values = String.getValues()
let A = Int64(values[0])!
let op = values[1]
let B = Int64(values[2])!

if op == "+" {
    print("\(A + B)")
} else {
    print("\(A - B)")
}
//  [swift]
let i=readLine()!.characters.split(" ").map{String($0)};print(i[1]=="+" ?Int(i[0])!+Int(i[2])!:Int(i[0])!-Int(i[2)!)
//  [swift]
let i=readLine()!.characters.split(" ").map{String($0)};print(i[1]=="+" ?Int(i[0])!+Int(i[1])!:Int(i[0])!-Int(i[1])!)
//  [typescript]
import * as fs from 'fs'

const input = fs.readFileSync('/dev/stdin', 'utf8').split('\n')
const [a, op, b] = input[0].split(' ')
console.log(op === '+' ? +a + +b : +a - +b)
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const icon = input[1];
  const A = parseInt(input[0], 10);
  const B = parseInt(input[2], 10);
 
  if (icon=="+") {
    console.log(A+B);
  }else{
    console.log(A-B);
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import { Hash } from "crypto";
import { access } from "fs";

class Input {
    private lines: string[];
    constructor(lines: string[]) {
        this.lines = lines;
    }

    public string(): string { return this.lines.shift() as string; }
    public int(): number { return parseInt(this.string()); }
    public intArray(): number[] { return this.string().split(" ").map(n => parseInt(n)); }
    public stringArray(): string[] { return this.string().split(" "); }

    public allLines(): string[] { return this.lines; }
    public allLinesInt(): number[] { return this.lines.map(s => parseInt(s)); }
    public allLinesIntArray(): number[][] { return this.lines.map(s => s.split(" ").map(n => parseInt(n))); }
    public allLinesStringArray(): string[][] { return this.lines.map(s => s.split(" ")); }
}


function calc(stdin: Input) {
    return eval(stdin.string())
}

function main(stdin: string) {
    console.log(calc(new Input(stdin.split("\n"))));
}

if (require.main && require.main.filename.indexOf("Main") >= 0) {
    main(require('fs').readFileSync('/dev/stdin', 'utf8'));
} else {
    main(require('fs').readFileSync('input.txt', 'utf8').trim());
}
//  [typescript]
import * as fs from 'fs';

const input = fs.readFileSync("/dev/stdin", "utf8").split('\n');
const a:number = +input[0];
const op:string =input[1];
const b:number = +input[2];
if(op == '+'){
	console.log(a+b);
}else{
	console.log(a-b);
}
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const icon = input[0];
  const A = parseInt(input[1], 10);
  const B = parseInt(input[2], 10);
 
  if (icon=="+") {
    console.log(A+B);
  }else{
    console.log(A-B);
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const icon = "+";
  const A = parseInt(input[0], 10);
  const B = parseInt(input[1], 10);
 
  if (icon=="+") {
    console.log(A+B);
  }else{
    console.log(A-B);
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
a,b=map(int,input().split())
print(a*b)
//  [python]
a, b = map(str, input().split())
A = int(a)
B = round(float(b) * 100)
print(A * B // 100)
//  [python]
def main():
    a, b = map(int, input().split())
    ans = a * b
    print(f'{ans}')


if __name__ == '__main__':
    main()
//  [python]
n = int(input())

def solve(n):
    res = 0
    for i in range(2, int(n ** 0.5) + 2):
        cnt = 0
        while n % pow(i, cnt + 1) == 0:
            n /= pow(i, cnt + 1)
            cnt += 1
            if n % pow(i, cnt + 1) != 0:
                res += cnt
                break
    
    if n != 1:
            res = 1
    
    return res

print(solve(n))
//  [python]
a, b = int(input())
print(a*b)
//  [python]
a, b = map(input().split())
print(a * b)
//  [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();
		int i = sc.nextInt();
		int j = sc.nextInt();
		
		System.out.println(i * j);
	}

}

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());}
}
//  [java]
/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
			PrintWriter out=new PrintWriter(System.out);
	FastScanner fs=new FastScanner();
		int a=fs.nextInt();
		int b=fs.nextInt();
		int ans=a*b;
		out.println(ans);
		out.close();
	
	
	}
	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}
		
		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
}
}
//  [java]
import java.util.Scanner;						  double(少数)
public class{								  string(文字)
	public static void main(String[] args) {
	    Scanner stdIn= new Scanner(System.in);
	    int x = stdIn.nextInt();
	    int y = stdIn.nextInt();
	    
	    System.out.println(x*y);
    }
}
//  [java]
import java.util.*;

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

    int n = sc.nextInt();
    long[] a = new long[n];
    long ans = 1;

    for(int i = 0; i < n; i++){
      a[i] = sc.nextLong();
      ans *= a[i];
        if(ans > Math.pow(10, 18)){
          ans = -1;
          break;
        }
    }

    System.out.println(ans);
  }
}
//  [java]
public class Main {
  public static void main(String[] args) {
    int A = new java.util.Scanner(System.in).nextInt();
    int B = new java.util.Scanner(System.in).nextInt();
    int C = A * B;
    System.out.println(C);
  }
}
//  [cpp]
#include <stdio.h>
int main(){
	int a,b;
	scanf("%d%d",&a,&b);
	printf("%d\n",a*b);
	return 0;
}
//  [cpp]
#include <cstdio>
#include <cctype>
using namespace std;
typedef long long ll;
void Read(int &x){
    static char c;
    while(!isdigit(c=getchar()));
    x=(c^48);
    while(isdigit(c=getchar()))
        x=x*10+(c^48);
    return;
}
void Print(int x){
    static int i;
    for(i=1;i*10LL<=x;i*=10);
    for(;i;i/=10)
        putchar(x/i%10|48);
    putchar('\n');
    return;
}
int main(){
    int a,b;
    Read(a);
    Read(b);
    Print(a*b);
    return 0;
}
//  [cpp]
#include<cstdio>
using namespace std;
int main()
{
	int a,b;
	scanf("%d%d",&a,&b);
	printf("%d\n",a*b);
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
int main(){
  int a, b;
  cout << a*b;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
int64_t a,c,d;
c=0;
d=0;
char b;
cin>>a;
vector<char> vec(3);
for(int64_t i=0;i<4;i++){
cin>>b;
if(b!='.'){vec.at(d)=b;
           d++;}
}
c=(int64_t)((vec.at(0)-'0')*100+(vec.at(1)-'0')*10+vec.at(2)-'0');
cout<<a*c/100<<endl;
}
//  [cpp]
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
int main()
{
  int N;
  cin>>N;
  int A[N];
  for (int i=0;i<N;i++)
    cin>>A;
  int ans=1;
  for(int i=0;i<=A[N];i++)
  {
    ans*=A[N];
  }
  if(ans>pow(10,18))
    cout<<"-1"<<endl;
  else 
    cout<<ans<<endl;
  return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define SIZE 100005
#define PI acosl(-1) //3.14159265358979323846264338327950L 
#define rep(i, N) for (i = 0; i < N; i++) //制御変数iを用いてN回転
#define array(N, t) (t*)calloc(N, sizeof(t)) //t型N要素の1次元配列を動的確保後0クリア(freeを忘れずに)
#define zero(a); {int iter; rep(iter, sizeof(a)/sizeof((a)[0])) (a)[iter]=0;} //1次元配列aのゼロ初期化?

typedef long long ll; typedef long double ld;
typedef struct node { int data; struct node *next; } Node;

Node *list[SIZE];
int queue[SIZE]; int q_head = 0, q_tail = 0;

void print_log(); //とりあえず文字を出力してどこまで実行できているか確認(for debug)
void printa_int(int *a, int size); //int型の1次元配列aを出力(for debug)
void printl_int(int size); //リンクリストを出力(for debug)
Node* add_node(int i, int data); void free_list(Node* head);
int queue_empty(); int queue_full();
void enqueue(int data); int dequeue();

int main() {
    int A, B;
    scanf("%d %d", &A, &B);
    printf("%d\n", A * B);
    return 0;
}

void print_log() {
    printf("=== print log ===\n");
}
void printa_int(int *a, int size) {
    int i;
    printf("[");
    for (i = 0; i < size; i++)
        printf("%d, ", a[i]);
    printf("]\n");
}
void printl_int(int size) {
    int i;
    Node *t;
    rep(i, size) {
        printf("[%d] ", i);
        for (t = list[i]; t; t = t->next) printf("%d, ", t->data);
        printf("\n");
    }
}
Node* add_node(int i, int data) {
    if (!list[i]) {
        list[i] = (Node*)malloc(sizeof(Node*));
        list[i]->data = data;
    } else {
        Node *t;
        t = list[i];
        list[i] = (Node*)malloc(sizeof(Node*));
        list[i]->data = data;
        list[i]->next = t;
    }
    return list[i];
}
void free_list(Node* head) {
    Node *prev = NULL, *t = head;
    while (t) {
        prev = t;
        t = t->next;
        free(prev);
    }
}
int queue_empty() {
    return q_head == q_tail;
}
int queue_full() {
    return (q_head - 1) % SIZE == q_tail % SIZE;
}
void enqueue(int data) {
    if (queue_full()) {
        printf("full!\n");
        return;
    }
    queue[q_tail++] = data;
    q_tail %= SIZE;
}
int dequeue() {
    if (queue_empty()) {
        printf("empty!\n");
        return -444444;
    }
    int data = queue[q_head++];
    q_head %= SIZE;
    return data;
}
//  [c]
#include <stdio.h>
int main(void){
	int a;
	int b;
	scanf("%d", &a);
	scanf("%d", &b);
	printf("%d\n", a*b);
	return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define rep(i,k,n) for(int (i)=(k);(i)<(n);(i)++)
#define max(a,b) (a)>(b)?(a):(b)
#define min(a,b) (a)<(b)?(a):(b)
#define abs(a) (a)>0 ?(a):-(a)
#define llong long long

int main(){
	int A,B; scanf("%d %d",&A,&B);
	printf("%d",A*B);
	return 0;
}
//  [c]
#include <stdio.h>
int main(){
  int a,b;
  scanf("%d %d",&a,&b);
  printf(a*b);
}
//  [c]
#include <stdio.h>
int main(){
  int a,b;
  scanf("%d %d",a,b);
  printf(a*b);
}
//  [c]
#include<stdio.h>
 
int main(){
  
 unsigned long long int a,ans;
 double b;
 
  (void) scanf("%llu %lf",&a,&b);
  printf("%llu %lf\n",a,b);
 
  ans=a*(b*100);
  ans=ans/100;
   
 printf("%llu",ans);
  
 return 0; 
}
//  [javascript]
function Main(input){
  const values = input.trim().split(' ').map((str)=> parseInt(str));
  const A = values[0];
  const B = values[1];
  
  console.log(A*B);
}

//固定
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split(" ");
	//文字列から10進数に変換するときはparseIntを使います
	var a = parseInt(input[0], 10);
	var b = parseInt(input[1], 10);
	//出力
	console.log('%d',a*b);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  input = input.split("\n");
  const A = parseInt(input[0].split(" ")[0]);
  const B = parseInt(input[0].split(" ")[1]);

  console.log(A * B);

// デバッグ用
function debug() {
  var input = document.getElementById("input").value;
  Main(input);
}

//* この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
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 input_int = parseInt(lines);
    console.log(lines[0] * lines[1]);
});
//  [javascript]
function main(input) {
    const strNumbers = input.split(" ");
    const a = strNumbers[0];
    const b = hundredTimesNormalization(strNumbers[1]);

    const result = Math.floor((a * b)/100);
    console.log(result);
}

const hundredTimesNormalization = (org) => {
    const [integer, decimal] = org.split('\.');
    const normalizationDecimal = ((typeof decimal == 'undefined' ? "" : decimal) + "0".repeat(2)).slice(0, 2);
    return ( Number( integer + normalizationDecimal));
}

// let input = "198 1.10";
// let input = "1 0.01";
// let input = "1000000000000000 9.99";
// let input = "0.07 100";
// let input = "1000000000000000 9.95";
// let input = "1 2.345"
// main(input);
main(require("fs").readFileSync("/dev/stdin","utf8"));


data.map(d => (d.date = new Date(d3.median(d, d => d.date)), d))
//  [go]
package main

import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	fmt.Println(a * b)
}
//  [go]
package main

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

func main() {
	fmt.Println(readInt() * readInt())
}

var (
	readString func() string
	readBytes  func() []byte
)

func init() {
	log.SetFlags(log.Lshortfile)
	readString, readBytes = newReadString(os.Stdin)
}

func newReadString(ior io.Reader) (func() string, func() []byte) {
	r := bufio.NewScanner(ior)
	r.Buffer(make([]byte, 1024), int(1e+11))
	r.Split(bufio.ScanWords)

	f1 := func() string {
		if !r.Scan() {
			panic("Scan failed")
		}
		return r.Text()
	}
	f2 := func() []byte {
		if !r.Scan() {
			panic("Scan failed")
		}
		return r.Bytes()
	}
	return f1, f2
}

func readInt64() int64 {
	i, err := strconv.ParseInt(readString(), 10, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

func readInt() int {
	return int(readInt64())
}

func readFloat64() float64 {
	f, err := strconv.ParseFloat(readString(), 64)
	if err != nil {
		panic(err.Error())
	}
	return f
}

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

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

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

func sum(a []int) int {
	var ret int
	for i := range a {
		ret += a[i]
	}
	return ret
}

func sumFloat64(a []float64) float64 {
	var ret float64
	for i := range a {
		ret += a[i]
	}
	return ret
}

func gcd(m, n int) int {
	for m%n != 0 {
		m, n = n, m%n
	}
	return n
}

func lcm(m, n int) int {
	return m / gcd(m, n) * n
}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var a, b int
  fmt.Scan(&a, &b)
  fmt.Println(a * b)
}
//  [go]
package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	var answer int64

	// N
	scanner.Scan()
	n, err := strconv.Atoi(scanner.Text())
	if err != nil {
		panic(err)
	}

	a := make([]int, n)

	for i := 0; i < n; i++ {
		scanner.Scan()
		num, err := strconv.Atoi(scanner.Text())
		if err != nil {
			panic(err)
		}
		a[i] = num
	}

	answer = int64(a[0])

	for i := 1; i < len(a); i++ {
		answer *= int64(a[i])
		if answer > int64(math.Pow(10, 18)) {
			fmt.Println("-1")
			os.Exit(1)
		}
	}

	fmt.Println(answer)

}
//  [go]
import sys


def log(s):
    # print("| " + str(s), file=sys.stderr)
    pass


def output(x):
    print(x, flush=True)


def input_ints():
    return list(map(int, input().split()))


def main():
    f = input_ints()
    print(f[0] * f[1])


main()
//  [ruby]
inputs = gets.strip.split.map(&:to_i)

puts inputs[0] * inputs[1]
//  [ruby]
a, b = gets.split.map(&:to_i)
puts a * b
//  [ruby]
ab = gets.chomp.split(" ").map!{|item| item.to_i}
puts ab[0] * ab[1]
//  [ruby]
n = gets.to_i
a = gets.split(" ").map(&:to_i)
i = 0
res = 1
 
while i < a.length do
  res = res * a[i]
  i += 1
end
 
if res > 10 ** 18
  puts "-1"
else
  puts res
end
//  [ruby]
a, b = gets.split(" ").map &:tp_i
puts a * b
//  [rust]
use proconio::input;


fn main() {
    input!{
        a: i32,
        b: i32,
    };
    
    println!("{}", a * b);
}
//  [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 a: u32 = read();
  let b: u32 = read();
  let ans = a * b;
  println!("{}", ans);
}
//  [rust]
use proconio::*;

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

    println!("{}", a * b);
}
//  [rust]
use std::io;

fn main(){
  let mut stdin = io::stdin();
  let mut buf = String::new();
  stdin.read_line(&mut buf).unwrap();
  buf.trim();
  let input = buf.split_whitespace().map(|n| n.parse::<u64>().unwrap()).collect::<Vec::<u64>>();
  println!("{}",input[0]*input[1]):
}
//  [rust]
use std::io;
use std::str::FromStr;

fn main() {
    let stdin = io::stdin();
    let mut buf = String::new();
    stdin.read_line(&mut buf).ok();
    let mut it = buf.split_whitespace().map(|n| usize::from_str(n).unwrap());
    let (n, m) = (it.next().unwrap(), it.next().unwrap());
    println!("%d", n * m);
}
//  [rust]
use std::io;

fn main() {
	let s = {
	    let mut s = String::new(); // バッファを確保
	    std::io::stdin().read_line(&mut s).unwrap(); // 一行読む。失敗を無視
	    s.trim_right().to_owned() // 改行コードが末尾にくっついてくるので削る
	};

	let (n, m) = {
	    let ws = s.split_whitespace(); // 空白区切りの単語に分解する
	    let n: i32 = ws.next().unwrap().parse().unwrap(); // イテレータから値を取り出して整数に
	    let m: i32 = ws.next().unwrap().parse().unwrap();
	    (n, m)
	};

	puts n * m;
}
//  [swift]
let i = readInts()
print(i[0] * i[1])


// MARK: -----------------------------------------------------------------------


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

extension Collection {
    func mapToTuple() -> (Element, Element) {
        var i = makeIterator()
        return (i.next()!, i.next()!)
    }
    func mapToTuple() -> (Element, Element, Element) {
        var i = makeIterator()
        return (i.next()!, i.next()!, i.next()!)
    }
    func mapToTuple() -> (Element, Element, Element, Element) {
        var i = makeIterator()
        return (i.next()!, i.next()!, i.next()!, i.next()!)
    }
    
    subscript(gen: Index) -> Element {
        _modify { yield &self[index(gen, offsetBy: -1)] }
        _read   { yield self[index(gen, offsetBy: -1)] }
    }
}

struct DP<Argument: Hashable, Element> {
    var dictionary = [Argument: Element]()
    
    var expression: (Argument, (Argument) -> Element) -> Element
    
    init(expression: @escaping (_ argument: Argument, _ note: (Argument) -> Element) -> Element) {
        self.expression = expression
    }
    
    subscript(_ argument: Argument) -> Element {
        mutating get {
            if let note = dictionary[argument] {
                return note
            } else {
                let result = expression(argument) { self[$0] }
                dictionary[argument] = result
                return result
            }
        }
    }
}
//  [swift]
let inputs = readLine()!.split(separator: " ").map { Int($0)! }
print(inputs[0] * inputs[1])
//  [swift]
import Foundation
func toTuple<T>(_ args: [T]) -> (T, T) { (args[0], args[1]) }
func toTuple<T>(_ args: [T]) -> (T, T, T) { (args[0], args[1], args[2]) }
func toTuple<T>(_ args: [T]) -> (T, T, T, T) { (args[0], args[1], args[2], args[3]) }
func readInts() -> [Int] { readLine()!.split(separator: " ").map { Int($0)! } }
func readDoubles() -> [Double] { readLine()!.split(separator: " ").map { Double($0)! } }

let (a, b) = toTuple(readInts())
print(a * b)
//  [swift]
var A = 10
var B = 5
print(A*B)
//  [swift]
var A = 10
var B = 5
var C = A*B
print(C)
//  [swift]
A = 10
B = 5
C = A*B
print(C)
//  [typescript]
import * as fs from 'fs';

const inputArray: string[] = fs.readFileSync("/dev/stdin", "utf8").split(' ');

const a: number = +inputArray[0];
const b: number = +inputArray[1];
const result = a * b;

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

const input = readFileSync("/dev/stdin", "utf8").split("\n");

const [a, b] = input[0].split(" ").map(Number);

const answer = a * b;

console.log(answer);
//  [typescript]
/**
 * A × B を求めてください。
 */

export function Main(input: string) {
  // 問題文解体エリア
  const inputs = input.split(" ");
  const num1 = new Number(inputs[0]).valueOf();
  const num2 = new Number(inputs[1]).valueOf();

  // 問題解決エリア
  const answer = fuck(num1, num2);

  //出力エリア
  console.log(answer);
}


//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
// 提出する時にコメントアウト解除せよ
Main(require("fs").readFileSync("/dev/stdin", "utf8"));

export function fuck(num1: number, num2: number): number {
  return num1 * num2;
}
//  [typescript]
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 input_int = parseInt(lines);
    console.log(lines[0] * lines[1]);
});
//  [python]

l=input().split()
if l[0]==l[1]:
    print("H")
else:
    print("D")
//  [python]
a, b = list(input().split())
if a == b:
    print('H')
else:
    print('D')
//  [python]
ab = input().split()

if ab[0] == 'H':
    if ab[1] == 'H':
        print('H')
    else:
        print('D')
else:
    if ab[1] == 'H':
        print('D')
    else:
        print('H')
//  [python]
a,b = input().split()
print("H" if (a=="H" and b=="H") or (a=="D" and b=="H") else "D")
//  [python]
a, b = input().split()
if a == b:
  print('D')
else:
  print('H')
//  [python]
a,b = map(str,input().split())

if s == b:
  print("H")
else:
  print("D")
//  [java]
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

public class Main {

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		char a = sc.next().toCharArray()[0];
		char b = sc.next().toCharArray()[0];

		if (a == 'H') {
			if (b == 'H') {
				System.out.println('H');
			} else {
				System.out.println('D');
			}
		} else {
			if (b == 'H') {
				System.out.println('D');
			} else {
				System.out.println('H');
			}
		}
	}

	private static boolean isDebug = System.getProperty("sun.desktop") != null;

	private static void debug(Object... o) {
		if (isDebug) {
			System.err.println(Arrays.deepToString(o));
		}
	}

	public static class Scanner {
		private BufferedInputStream inputStream;

		public Scanner(InputStream in) {
			inputStream = new BufferedInputStream(in);
		}

		public int nextInt() throws IOException {
			int num = 0;

			int read = skip();
			do {
				num = num * 10 + (read - 0x30);
			} while ((read = inputStream.read()) > 0x20);

			return num;
		}

		public void fill(int[] a) throws IOException {
			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
			}
		}

		public void fill(int[] a, int[] b) throws IOException {
			if (a.length != b.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
				b[i] = nextInt();
			}
		}

		public long nextLong() throws IOException {
			long num = 0;

			int read = skip();
			do {
				num = num * 10 + (read - 0x30);
			} while ((read = inputStream.read()) > 0x20);

			return num;
		}

		public void fill(long[] a) throws IOException {
			for (int i = 0; i < a.length; i++) {
				a[i] = nextLong();
			}
		}

		public void fill(long[] a, long[] b) throws IOException {
			if (a.length != b.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextLong();
				b[i] = nextLong();
			}
		}

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

			return array;
		}

		public String next() throws IOException {
			StringBuilder builder = new StringBuilder();

			int read = skip();
			do {
				builder.append((char) read);
			} while ((read = inputStream.read()) > 0x20);

			return builder.toString();
		}

		private int skip() throws IOException {
			int read;
			while ((read = inputStream.read()) <= 0x20)
				;

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

public class Main {
    public static PrintWriter out;
    public static FastScanner in;

    private void solve(){
        String a = in.next();
        String b = in.next();

        if(a.charAt(0) == b.charAt(0)|| a.charAt(0) == b.charAt(0)){
            out.print('H');
            return;
        }

        out.print('D');
    }

    private void runIO() {
        in = new FastScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));
        solve();
        out.close();
    }
    private static class FastScanner {
        BufferedReader bufferedReader;
        StringTokenizer stringTokenizer;

        private FastScanner() {
            bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        }

        private String next() {
            if (stringTokenizer == null || !stringTokenizer.hasMoreElements()) {
                try {
                    stringTokenizer = new StringTokenizer(bufferedReader.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return stringTokenizer.nextToken();
        }

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

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

        private String nextLine() {
            String ret = "";
            try {
                ret = bufferedReader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return ret;
        }
    }

    public static void main(String[] args) {
        new Main().runIO();
    }
}
//  [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 a = saori.nextHayami();
		String b = saori.nextHayami();
		if(a.equals("H") && b.equals("H")){
			System.out.println("H");
		}
		if(a.equals("H") && b.equals("D")){
			System.out.println("D");
		}
		if(a.equals("D") && b.equals("H")){
			System.out.println("D");
		}
		if(a.equals("D") && b.equals("D")){
			System.out.println("H");
		}
		
		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.Scanner;
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.println(b);
		}else{
		    String ans = "D";
		    System.out.println(ans);
		}
    }
}
//  [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 == "D"){
      if(b.equals("H")) b = "D";
      else b = "H";
    }
    System.out.println(b);
  }
}
//  [cpp]
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;

char a, b;
bool flag;

int main(){
	scanf("%c %c", &a, &b);
	if(a == b) flag = 1;
	else flag = 0;
	if(flag == 1) printf("H\n");
	else printf("D\n");
}
//  [cpp]
#include <cstdio>
using namespace std;
char s1[4],s2[4];
int main(){
      scanf("%s%s",s1,s2);
      putchar(s1[0]==s2[0]?'H':'D');
}
//  [cpp]
#include<stdio.h>
int main()
{
    char a,b;
    scanf("%c %c",&a,&b);
    if(a=='H')
        printf("%c",b);
    else if(a=='D')
    {
        if(b=='H')
            printf("D");
        else if(b=='D')
           printf("H");
    }
    return 0;

}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main()
{
	string a,b;
	cin>>a>>b;
	if(a==b)
	{
		cout<<"H"<<endl;
	}
	else if(a=="H" && b=="D")
	{
		cout<<"H"<<endl;
	}
	else if(a=="D" && b=="H")
	{
		cout<<"H"<<endl;
	}
	else
	{
		cout<<"D";
	}
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main()
{
	string a,b;
	cin>>a>>b;
	if(a==b)
	{
		cout<<"H"<<endl;
	}
	else if(a=="H" && b=="D")
	{
		cout<<"H"<<endl;
	}
	else
	{
		cout<<"D";
	}
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main()
{
	string a,b;
	cin>>a>>b;
	if(a=="H" && b=="H")
	{
		cout<<"H"<<endl;
	}
	else if(a=="H" && b=="D")
	{
		cout<<"H"<<endl;
	}
	else
	{
		cout<<"D";
	}
	return 0;
}
//  [c]
#include<stdio.h>
#include<string.h>

int main(void)
{
  char a,b,dammy;
  scanf("%c%c%c",&a,&dammy,&b);
  if(a=='H')
    printf("%c\n",b);
  else if(b=='H')
    printf("D\n");
  else
    printf("H\n");
  return 0;
}
//  [c]
#include <stdio.h>
 
int main()
{
  char a,b;
  scanf("%c %c",&a,&b);
  if ((a == 'H' && b == 'H') || (a != 'H' && b != 'H'))
    printf("H");
  else
    printf("D");
}
//  [c]
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a,b;
    scanf("%c %c",&a,&b);
    if(a=='H')
        printf("%c",b);
        else
        {
            if(b=='H')
        printf("D");
        else
            printf("H");
        }
    return 0;
}
//  [c]
#include <bits/stdc++.h>

using namespace std;


int main() {
    char a, b;
    cin >> a >> b;
    
    if (a == 'H') {
      if (b == 'H') {
        cout << "H" << endl;;
      } else {
        cout << "H" << endl;;
      }
    } else {
      if (b == 'H') {
          cout << "D" << endl;
      } else {
        cout << "H" << endl;;
      }
    }
}
//  [c]
#include <iostream>

using namespace std;


int main() {
    char a, b;
    cin >> a >> b;
    
    if (a == 'H') {
      if (b == 'H') {
        cout << "H" << endl;;
      } else {
        cout << "H" << endl;;
      }
    } else {
      if (b == 'H') {
          cout << "D" << endl;
      } else {
        cout << "H" << endl;;
      }
    }
}
//  [c]
#include <stdio.h>

int main(void)
{
        char s,t;
        scanf("%c%c",&s,&t);
        if(s=='H'){
                if(t=='H')printf("H\n");
                else if(t=='D')printf("D\n");
        }
        else {
                if(t=='H')printf("D\n");
                else if(t=='D')printf("H\n");
        }
        return 0;
}
//  [javascript]
"use strict";
    
const main = arg => {
    const a = arg.split("\n")[0].split(" ")[0];
    const b = arg.split("\n")[0].split(" ")[1];
    
    if(a=="D") {
        console.log(b == "H" ? "D" : "H");   
    } else {
        console.log(b);
    }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
"use strict";
function Main(input){
	let xs = input.trim().split(' ')
    //console.log(xs[0],xs[1]);
    if(xs[0]=='D' && xs[1]=='D' || xs[0]=='H' && xs[1]=='H'){
    	console.log('H'); 
    } else {
    	console.log('D');
    }
}
Main(require('fs').readFileSync('/dev/stdin','utf8'));
//  [javascript]
function Main(input) {
  input=input.trim();
  var A = input.split(" ")[0];
  var B = input.split(" ")[1];
  if(A == "H"){
    console.log(B);
  }else{
    console.log((B === "H") ? "D" : "H");
  }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input){
  const args = input.trim().split("");
  const a = args[0],
        b = args[1];
  
  if (a == b)
    console.log("H");
  else
    console.log("D");
}
 
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input){
  const args = input.split(" ");
  const a = args[0],
        b = args[1];
  
  if (a == b)
    console.log("H");
  else
    console.log("D");
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input){
  const args = input.split(" ");
  const a = args[0],
        b = args[1];
  
  if (a == "H")
    console.log(b);
  else
    if (b == "H")
      console.log("D");
    else
      console.log("H");
}

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

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

const (
	initialBufSize = 1e4
	maxBufSize     = 1e6 + 7
)

var buf []byte = make([]byte, maxBufSize)
var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(buf, maxBufSize)
}

func main() {
	if nextLine() == nextLine() {
		fmt.Println("H")
	} else {
		fmt.Println("D")
	}
}

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

func pow(p, q int) int {
	res := p
	if q == 0 {
		return 1
	}
	for i := 0; i < q-1; i++ {
		res *= p
	}
	return res
}

func MinOf(vars ...int) int {
	min := vars[0]
	for _, i := range vars {
		if min > i {
			min = i
		}
	}
	return min
}

func MaxOf(vars ...int) int {
	max := vars[0]
	for _, i := range vars {
		if max < i {
			max = i
		}
	}
	return max
}

func gcdof2numbers(a int, b int) int {
	if b == 0 {
		return a
	}
	return gcdof2numbers(b, a%b)
}

func lcmof2numbers(a int, b int) int {
	return a / gcdof2numbers(a, b) * b
}

// マイナスの場合は考慮していない
func fuctorial(a int) int {
	if a == 1 || a == 0 {
		return 1
	} else {
		return fuctorial(a-1) * a
	}
}

func NextPermutation(x sort.Interface) bool {
	n := x.Len() - 1
	if n < 1 {
		return false
	}
	j := n - 1
	for ; !x.Less(j, j+1); j-- {
		if j == 0 {
			return false
		}
	}
	l := n
	for !x.Less(j, l) {
		l--
	}
	x.Swap(j, l)
	for k, l := j+1, n; k < l; {
		x.Swap(k, l)
		k++
		l--
	}
	return true
}

// 素因数分解したmapを返す
func primeFuctorize(n int) map[int]int {
	pf := map[int]int{}
	for i := 2; i*i <= n; i++ {
		for n%i == 0 {
			pf[i]++
			n /= i
		}
	}
	if n != 1 {
		pf[n]++
	}
	return pf
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b string
	fmt.Scan(&a, &b)
	if a == b {
		fmt.Println("H")
	} else {
		fmt.Println("D")
	}
}
//  [go]
package main

import "fmt"

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

	if a == "H" {
		if b == "H" {
			fmt.Println("H")
		} else {
			fmt.Println("D")
		}
	} else {
		if b == "H" {
			fmt.Println("D")
		} else {
			fmt.Println("H")
		}
	}
}