Go: package main

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

var scanner = bufio.NewScanner(os.Stdin)

func main() {
	for scanner.Scan() {
		buf := strings.Split(scanner.Text(), " ")
		n, _ := strconv.Atoi(buf[0])
		x, _ := strconv.Atoi(buf[1])
		if n == 0 && x == 0 {
			break
		}
		prime_table := make([]int, 1000001)
		prime_table[0] = -1
		prime_table[1] = -1
		for i := 2; i < 1000001; i++ {
			if prime_table[i] != -1 {
				prime_table[i] = 1
				for j := 2*i; j < 1000001; j += i {
					prime_table[j] = -1 // -1 means "not prime"
				}
			}
		}
		dp := make([]int, x+1)
		dp[0] = 1
		menu := make([]int, n)
		for i := 0; i < n; i++ {
			scanner.Scan()
			menu[i], _ = strconv.Atoi(scanner.Text())
		}
		for i := 0; i < n; i++ {
			for j := 0; j <= x; j++ {
				if menu[i] <= j && dp[j-menu[i]] != 0 {
					// log.Println(dp)
					dp[j] = 1
				}
			}
		}
		flag := true
		for j := x; j >= 0; j-- {
			if prime_table[j] == 1 && dp[j] == 1 {
				flag = false
				fmt.Println(j)
				break
			}
		}
		if flag {
			fmt.Println("NA")
		}
	}
}

Python: from sys import stdin
readline = stdin.readline


import math
def sieve(n):
    p = [1] * (n + 1)
    p[0] = p[1] = 0
    
    for i in range(math.ceil((n + 1) ** 0.5)):
        if p[i]:
            for j in range(2 * i, len(p), i):
                p[j] = 0
    return p

prime = sieve(1000000)

def solve(price, x):
    dp = [0] * (x + 1)
    dp[0] = 1

    price.sort()
    for pi in price:
        for i in range(0, len(dp), pi):
            dp[i] = 1
    for pi in price[1:]:
        for i in range(pi, len(dp)):
            if not dp[i] and dp[i - pi]:
                dp[i] = 1
    for i in reversed(range(2, len(dp))):
        if dp[i] and prime[i]:
            return i
    return None

def main():
    while True:
        n, x = map(int, readline().split())
        if n == 0:
            break
        price = [int(readline()) for _ in range(n)]
        amount = solve(price, x)
        print(amount if amount else 'NA')
main()

Python: from datetime import datetime

def measure(f):
    measure_start = datetime.now()
    v = f()
    print(datetime.now() - measure_start)
    return v

# input = raw_input
# range = xrange
    
def init():
    table = [True] * 1000001
    table[0] = False
    table[1] = False
    n = len(table)

    def prime(p):
        for i in range(p + p, n, p):
            table[i] = False
    prime(2)
    prime(3)
    prime(5)
    prime(7)
    prime(11)
    prime(13)
    
    for i in range(2, n):
        if (i % 2 != 0 and i % 3 != 0 and i % 5 != 0 and
            i % 7 != 0 and i % 11 != 0 and i % 13 != 0):
            for j in range(i + i, n, i):
                table[j] = False
    return table
    
def solve(price, ps, is_prime):
    dp = [0] * ((price >> 6) + 1)

    for i in range(0, price + 1,ps[0]):
        dp[i >> 6] |= 1 << (i & 63)
    dp[0] = 1
    
    for i in range(1, len(ps)):
        cur_p = ps[i]
        r = cur_p & 63
        rest = 0
        
        for p in range(cur_p, price + 1, 64):
            i1 = (p - cur_p) >> 6
            i2 = p >> 6
            v = dp[i1]
            dp[i2] |= (v << r) | rest
            v = dp[i1]
            dp[i2] |= (v << r) | rest
            rest = (v >> (64 - r)) & ((1 << r) - 1)
            
    p = -1
    for i in range(0, price + 1):
        if is_prime[i] and (dp[i >> 6] >> (i & 63)) & 1 == 1:
            p = i
    if p == -1:
        print("NA")
    else:
        print(p)
    
def main():
    table = init()
    while True:
        n, price = map(int,input().split())
        if n == 0 and price == 0:
            return
        ps = []
        for i in range(n):
            ps.append(int(input()))
        solve(price, ps, table)

main()

Python: def sieve():
    p = [1] * 1000001;p[0] = p[1] = 0
    
    for i in range(1000):
        if p[i]:
            for j in range(i * i, 1000001, i):p[j] = 0
    return p

def solve(p, menu, x):
    menu.sort()
    
    num = [0] * (x + 1)
    num[0] = 1
    
    for mi in menu:
        if num[mi]:
            continue
        for i in range(len(num) - mi):
            if num[i] and not num[i + mi]:
                num[i + mi] = 1
                
    for i in reversed(range(1, len(num))):
        if p[i] and num[i]:
            return i
    return 'NA'

import sys
f = sys.stdin

p = sieve()
while True:
    
    n, x = map(int, f.readline().split())
    if n == 0:
        break
    menu = [int(f.readline()) for _ in range(n)]
    print(solve(p, menu, x))

Python: isPrime = [False,False]+[True]*(1000000-2)
isPrime[4::2] = [False]*len(isPrime[4::2])
for i in range(3,1000,2):
    if isPrime[i]:
        isPrime[2*i::i] = [False]*len(isPrime[2*i::i])

while True:
    n,x = [int(i) for i in input().split()]
    if n==0: break
    prices = [int(input()) for i in range(n)]
    isPayable = [True]+[False]*x
    for pri in prices:
        for i in range(0,x-pri+1):
            if isPayable[i]:
                isPayable[i+pri] = True
    li = [i for i in range(x+1) if isPayable[i] and isPrime[i]]
    print(max(li) if li else 'NA')

Python: # -*- coding: utf-8 -*-
import sys,math

#Debug=True
Debug=False
nmax=1000000
unit_cost = []
total_cost=0
pmax=-1
dic = {2:True,3:True}

def prime3(n):
    global dic
    if n in dic:
        return(dic[n])
    else:
        if n % 2==0:
            return False
        while True:
            for i in range(3,math.ceil(math.sqrt(n))+1,2):
                if n % i == 0:
                    dic[n]=False
                    return(False)
            dic[n]=True
            return(True)

def cost_gen1(money, lvl=0, lst=[]):
    uc = unit_cost[lvl]
    if lvl==len(unit_cost)-1:
        yield uc * math.floor(money/uc)
    else:
        for i in range(int(money/uc),-1,-1):
            tot_uc = uc*i
            rem = money - tot_uc
            if rem < unit_cost[lvl+1]:
                yield tot_uc
            else:
                for j in cost_gen1(rem, lvl+1):
                    yield  j + tot_uc

def check_mutually_prime(v):
    s = min(v)
    for i in range(2,s+1):
        if sum(map(lambda x:x%i, v))==0:
            return False
    return True
    
def main():
    global unit_cost, total_cost, pmax
    if not Debug:
        fh=sys.stdin
    else:
        #fh=open('vol2_0202b.txt', 'r')
        fh=open('vol2_0202.txt', 'r')
        #pdb.set_trace()

    while True:
        m, total_cost = list(map(int, fh.readline().strip().split()))
        if m==0:
            break
        v=[]
        for _ in range(m):
            v.append(int(fh.readline()))
        unit_cost = sorted(v, reverse=True)   # 大きい順
        print('NA')
        continue


        # 互いに素(relative prime)、でないときの処理
        if not check_mutually_prime(unit_cost):
            print('NA')
            continue
        #t0=time.time()
        p=[]
        pmax=-1
        gen=cost_gen1(total_cost, 0)
        for i in gen:
            if i > pmax and prime3(i):
                p.append(i)
                pmax=max(p)
                if pmax==total_cost:
                    break
        print(pmax)
            
        #if Debug:
        #    print('t=', time.time()-t0)
    fh.close()
	            
if __name__ == "__main__":
    main()

Python: # AOJ 0202: At Boss's Expense
# Python3 2018.6.26 bal4u

MAX = 1000000
SQRT = 1000     # sqrt(MAX)

not_prime = [0]*(MAX+3)
def sieve():
	for i in range(3, SQRT, 2):
		if not_prime[i] == 0:
			for j in range(i*i, MAX, i): not_prime[j] = 1

sieve()
v = [0]*33
while True:
	n, x = map(int, input().split())
	if n == 0: break
	mk = [0]*(x+3)
	for i in range(n): v[i] = int(input())
	mk[0] = 1
	for k in range(x):
		if mk[k]:
			for i in range(n):
				if k+v[i] <= x: mk[k+v[i]] = 1
	ans = -1
	if x <= 2:
		if mk[x]: ans = x
	else:
		if (x & 1) == 0: x -= 1
		while x > 0:
			if mk[x] and not_prime[x] == 0:
				ans = x
				break
			x -= 2
	print(ans if ans >= 0 else "NA")