Chef has a natural number N. Cheffina challenges chef to check whether the given number is divisible by the sum of its digits or not. If the given number is divisible then print "Yes" else "No".

-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow. 
- Each test case contains a single line of input, $N$. 

-----Output:-----
For each test case, output in a single line answer.

-----Constraints-----
- $1 \leq T \leq 10^6$
- $1 \leq N \leq 10^6$

-----Sample Input:-----
2
16
27

-----Sample Output:-----
No
Yes

Difficulty: interview

Starter code:

Solutions:
import sys,io,os,math
from math import ceil,log,gcd,inf
from itertools import permutations
mod=1000000007
mod1=998244353
def printlist(n):
    sys.stdout.write(" ".join(map(str,n)) + "\n")
printf=lambda n:sys.stdout.write(str(n)+"\n")
def printns(n):
    sys.stdout.write(str(n))   
def intinp():
    return int(sys.stdin.readline())
def strinp():
    return sys.stdin.readline()
def arrinp():
    return list(map(int,sys.stdin.readline().strip().split()))
def mulinp():
    return list(map(int,sys.stdin.readline().strip().split()))
def flush():
    return sys.stdout.flush()
def power_two(x):
    return (1<<x)
def lcm(a,b):
	return a*b//gcd(a,b)   
def solve():
        n=intinp()
        ans=str(n)
        count=0
        for i in ans:
                count+=int(i)
        if(n%count==0):
                print('Yes')
                return 0
        print('No')


def main():
    tc=intinp()
    while(tc):
        solve()
        tc-=1	
	
main()



def f(n):
    sod = 0
    for char in str(n):
        sod += int(char)
    if n%sod == 0:
        return "Yes"
    else:
        return "No"

t = int(input())
answers = list()
for _ in range(t):
    n = int(input())
    answers.append(f(n))

for answer in answers:
    print(answer)

import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
#______________________________________________________________________________________________________
# from math import *
# from bisect import *
# from heapq import *
# from collections import defaultdict as dd
# from collections import OrderedDict as odict
from collections import Counter as cc
# from collections import deque
# sys.setrecursionlimit(2*(10**5)+100) this is must for dfs
mod = 10**9+7; md = 998244353
# ______________________________________________________________________________________________________
# segment tree for range minimum query
# sys.setrecursionlimit(10**5)
# n = int(input())
# a = list(map(int,input().split()))
# st = [float('inf') for i in range(4*len(a))]
# def build(a,ind,start,end):
# 	if start == end:
# 		st[ind] = a[start]
# 	else:
# 		mid = (start+end)//2
# 		build(a,2*ind+1,start,mid)
# 		build(a,2*ind+2,mid+1,end)
# 		st[ind] = min(st[2*ind+1],st[2*ind+2])
# build(a,0,0,n-1)
# def query(ind,l,r,start,end):
# 	if start>r or end<l:
# 		return float('inf')
# 	if l<=start<=end<=r:
# 		return st[ind]
# 	mid = (start+end)//2
# 	return min(query(2*ind+1,l,r,start,mid),query(2*ind+2,l,r,mid+1,end))
# ______________________________________________________________________________________________________
# Checking prime in O(root(N))
# def isprime(n):
#     if (n % 2 == 0 and n > 2) or n == 1: return 0
#     else:
#         s = int(n**(0.5)) + 1
#         for i in range(3, s, 2):
#             if n % i == 0:
#                 return 0
#         return 1
# def lcm(a,b):
#   return (a*b)//gcd(a,b)
# ______________________________________________________________________________________________________
# nCr under mod
# def C(n,r,mod):
#   if r>n:
#       return 0
#   num = den = 1
#   for i in range(r):
#       num = (num*(n-i))%mod
#       den = (den*(i+1))%mod
#   return (num*pow(den,mod-2,mod))%mod
# M = 10**5 +10
# ______________________________________________________________________________________________________
# For smallest prime factor of a number
# M = 1000010
# pfc = [i for i in range(M)]
# def pfcs(M):
#   for i in range(2,M):
#       if pfc[i]==i:
#           for j in range(i+i,M,i):
#               if pfc[j]==j:
#                   pfc[j] = i
#   return
# pfcs(M)
# ______________________________________________________________________________________________________
tc = 1
tc, = inp()
for _ in range(tc):
	n, = inp()
	a = [int(i) for i in str(n)]
	print("Yes" if n%sum(a)==0 else "No")

from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
def remadd(x, y): return 1 if x%y else 0
def ceil(a,b): return (a+b-1)//b

def isprime(x):
    if x<=1: return False
    if x in (2, 3): return True
    if x%2 == 0: return False
    for i in range(3, int(sqrt(x))+1, 2):
        if x%i == 0: return False
    return True

for _ in range(int(inp())):
    n = int(inp())
    ans = 0
    k = n
    while(n):
        ans += n%10
        n//=10
    print("Yes" if k%ans==0 else "No")

from sys import*
input=stdin.readline
t=int(input())
for _ in range(t):
    s=input()
    n=int(s)
    n1=n
    l=list(s)
    s1=0
    while n1!=0:
        s1+=n1%10
        n1//=10
    if n%s1==0:
        print("Yes")
    else:
        print("No")