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: # -*- coding: utf-8 -*-
import sys,math
import pdb

#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=[]):
#    try:
        uc = unit_cost[lvl]
        if lvl==len(unit_cost)-1:
            yield uc * (money//uc)
        else:
            for i in range(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
 #   except Exception:
 #       print('NA')
    

    

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)   # 大きい順


        # 互いに素(relative prime)、でないときの処理
        if not check_mutually_prime(unit_cost):
            print('NA')
            continue
        #t0=time.time()
    #    print('NA')
    #    continue

        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: N=1000000

isPrime = [False,False]+[True]*(N-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,g = [int(i) for i in input().split()]
    prices = [int(input()) for i in range(n)]
    if n==0 and g==0: break
    isPayable = [True]+[False]*g
    for pri in prices:
        for i in range(0,g-pri):
            if isPayable[i]:
                isPayable[i+pri] = True
    for i in reversed(range(g+1)):
        if i == 0:
            print('NA')
        if isPrime[i] and isPayable[i]:
            print(i)
            break

Python: from datetime import datetime

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

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 = [False] * (price + 1)

    if ps[0] <= price:
        dp[ps[0]] = True
    dp[0]     = True

    for i in range(1, len(ps)):
        cur_p = ps[i]
        for p in range(price + 1):
            if p >= cur_p:
                dp[p] = dp[p] or dp[p - cur_p]

    p = -1
    for i in range(0, price + 1):
        if is_prime[i] and dp[i]:
            p = i
    if p == -1:
        print("NA")
    else:
        print(p)
    
def main():
    table = measure(lambda : 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: from datetime import datetime

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

# input = raw_input
    
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 = [False] * (price + 1)

    if ps[0] <= price:
        dp[ps[0]] = True
    dp[0]     = True

    for i in range(1, len(ps)):
        cur_p = ps[i]
        for p in range(cur_p, price + 1):
            dp[p] = dp[p] or dp[p - cur_p]

    p = -1
    for i in range(0, price + 1):
        if is_prime[i] and dp[i]:
            p = i
    if p == -1:
        print("NA")
    else:
        print(p)
    
def main():
    table = measure(lambda : 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: 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:
        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()