fork(1) download 
  1. import java.util.*;
  2. import java.lang.*;
  3. import java.io.*;
  4. import java.util.regex.*;
  5.  
  6. class Ideone
  7. {
  8. 	public static void main (String[] args) throws java.lang.Exception
  9. 	{
  10. 		try {
  11. 			BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
  12. 			Excutor excutor = new Excutor();
  13. 			String line;
  14. 			while ((line = in.readLine()) != null) {
  15. 				try {
  16. 					List<Token> tokens = Tokenizer.tokenize(line);
  17. 					if (excutor.doEditorCommand(tokens) < 0) {
  18. 						break;
  19. 					}
  20. 				} catch (SyntaxError er) {
  21. 					System.out.println(er);
  22. 				}
  23. 			}
  24. //			System.out.println(excutor);
  25. 		} catch (Exception ex) {
  26. 			System.out.println(ex);
  27. 		}
  28.  
  29. 	}
  30. }
  31.  
  32. enum TokenType
  33. {
  34. 	INT, DBL, STR, NAME, SYMBL, SHARP, SEMICOLON,
  35. 	OP_BRKT, CL_BRKT, COMMA, COLON, UNKNOWN
  36. }
  37.  
  38. final class Token
  39. {
  40. 	final TokenType type;
  41. 	final String token;
  42. 	public Token(TokenType type, String token)
  43. 	{
  44. 		this.type = type;
  45. 		this.token = token;
  46. 	}
  47. 	public TokenType getType() { return type; }
  48. 	public String getToken() { return token; }
  49. 	@Override
  50. 	public String toString()
  51. 	{
  52. 		return "[" + type + " : " + token + "]";
  53. 	}
  54. }
  55.  
  56. class SyntaxError extends java.lang.Exception
  57. {
  58. 	public SyntaxError(String msg) { super(msg); }
  59. 	public SyntaxError(Throwable ex) { super(ex); }
  60. 	public SyntaxError(List<Token> tokens, int index)
  61. 	{
  62. 		super("token index(" + index + "): " + tokens.toString());
  63. 	}
  64. }
  65.  
  66. final class TokenError extends SyntaxError
  67. {
  68. 	public TokenError(String line) { super(line); }
  69. }
  70.  
  71. final class Tokenizer
  72. {
  73. 	private static Pattern p_space = Pattern.compile("^\\s+");
  74. 	private static Pattern p_int = Pattern.compile("^\\d+");
  75. 	private static Pattern p_dbl = Pattern.compile("^\\d*\\.\\d+");
  76. 	private static Pattern p_str = Pattern.compile("^\"(\"\"|[^\"])*\"");
  77. 	private static Pattern p_name = Pattern.compile("^[A-Za-z][A-Za-z0-9]*\\$?");
  78. 	private static Pattern p_symbl = Pattern.compile("^(>=|<=|<>|[=<>+\\*/-])");
  79.  
  80. 	public static List<Token> tokenize(String line) throws TokenError
  81. 	{
  82. 		List<Token> list = new ArrayList<Token>();
  83. 		Matcher m = null;
  84. 		TokenType type = null;
  85. 		String token = null;
  86. 		int offset = 0;
  87.  
  88. 		while (line.length() > 0) {
  89. 			if ((m = p_space.matcher(line)).lookingAt()) {
  90. 				line = line.substring(m.end());
  91. 				continue;
  92. 			} else if ((m = p_dbl.matcher(line)).lookingAt()) {
  93. 				type = TokenType.DBL;
  94. 			} else if ((m = p_int.matcher(line)).lookingAt()) {
  95. 				type = TokenType.INT;
  96. 			} else if ((m = p_str.matcher(line)).lookingAt()) {
  97. 				type = TokenType.STR;
  98. 			} else if ((m = p_name.matcher(line)).lookingAt()) {
  99. 				type = TokenType.NAME;
  100. 			} else if ((m = p_symbl.matcher(line)).lookingAt()) {
  101. 				type = TokenType.SYMBL;
  102. 			} else {
  103. 				m = null;
  104. 				offset = 1;
  105. 				if (line.startsWith(token = "(")) {
  106. 					type = TokenType.OP_BRKT;
  107. 				} else if (line.startsWith(token = ")")) {
  108. 					type = TokenType.CL_BRKT;
  109. 				} else if (line.startsWith(token = ":")) {
  110. 					type = TokenType.COLON;
  111. 				} else if (line.startsWith(token = ",")) {
  112. 					type = TokenType.COMMA;
  113. 				} else if (line.startsWith(token = "#")) {
  114. 					type = TokenType.SHARP;
  115. 				} else if (line.startsWith(token = ";")) {
  116. 					type = TokenType.SEMICOLON;
  117. 				} else {
  118. 					throw new TokenError(line);
  119. 				}
  120. 			}
  121. 			if (m != null) {
  122. 				token = m.group();
  123. 				if (TokenType.NAME.equals(type)) {
  124. 					token = token.toUpperCase();
  125. 				}
  126. 				offset = m.end();
  127. 			}
  128. 			list.add(new Token(type, token));
  129. 			line = line.substring(offset);
  130. 		}
  131. 		return list;
  132. 	}
  133. }
  134.  
  135. final class ExcuteError extends SyntaxError
  136. {
  137. 	public ExcuteError(Throwable ex) { super(ex); } 
  138. 	public ExcuteError(String msg) { super(msg); } 
  139. }
  140.  
  141. class VarArray<T>
  142. {
  143.  
  144. }
  145.  
  146. enum ResultType
  147. {
  148. 	INT, DBL, STR
  149. }
  150.  
  151. class Result
  152. {
  153. 	private int offset;
  154. 	private int intvalue = 0;
  155. 	private double dblvalue = 0;
  156. 	private String strvalue = null;
  157. 	private ResultType type;
  158.  
  159. 	public ResultType getType()
  160. 	{
  161. 		return type;
  162. 	}	
  163.  
  164. 	public int getOffset()
  165. 	{
  166. 		return offset;
  167. 	}
  168.  
  169. 	public Number getNumValue()
  170. 	{
  171. 		if (ResultType.INT.equals(type)) {
  172. 			return Integer.valueOf(intvalue);
  173. 		} else if (ResultType.DBL.equals(type)) {
  174. 			return Double.valueOf(dblvalue);
  175. 		} else {
  176. 			return null;
  177. 		}
  178. 	}
  179. 	public String getStrValue()
  180. 	{
  181. 		return strvalue;
  182. 	}
  183. }
  184.  
  185. final class Excutor
  186. {
  187. 	private NavigableMap<Integer, List<Token>> program = new TreeMap<Integer, List<Token>>();
  188.  
  189. 	private Map<String, VarArray<String>> strarrs = new HashMap<String, VarArray<String>>();
  190. 	private Map<String, VarArray<Number>> numarrs = new HashMap<String, VarArray<Number>>();
  191. 	private Map<String, String> strvars = new HashMap<String, String>();
  192. 	private Map<String, Number> numvars = new HashMap<String, Number>();
  193.  
  194. 	private Integer programcounter = null;
  195. 	private Deque<Integer> programcounterstack = new ArrayDeque<Integer>();
  196.  
  197. 	private int arraybase = 0;
  198. 	private boolean jumpflag = false;
  199.  
  200. 	public Excutor() {}
  201.  
  202. 	private void printLine(Integer linenum, List<Token> tokens)
  203. 	{
  204. 		System.out.printf("%05d ", linenum.intValue());
  205. 		TokenType before = null, type;
  206. 		for (int i = 1; i < tokens.size(); i++) {
  207. 			Token token = tokens.get(i);
  208. 			type = token.getType();
  209. 			if (TokenType.NAME.equals(before)) {
  210. 				switch (type) {
  211. 					case NAME:
  212. 					case INT:
  213. 					case DBL:
  214. 					case SHARP:
  215. 					case STR:
  216. 						System.out.print(' ');
  217. 						break;
  218. 					default:
  219. 						break;
  220. 				}
  221. 			}
  222. 			System.out.print(tokens.get(i).getToken());
  223. 			before = type;
  224. 		}
  225. 		System.out.println();
  226. 	}
  227.  
  228. 	private Result calc(List<Token> tokens, int index) throws SyntaxError
  229. 	{
  230. 		return null;
  231. 	}
  232.  
  233. 	public int doEditorCommand(List<Token> tokens) throws SyntaxError
  234. 	{
  235. 		if (tokens == null || tokens.isEmpty()) {
  236. 			return 0;
  237. 		}
  238.  
  239. 		Token first = tokens.get(0);
  240. 		String token = first.getToken();
  241. 		TokenType type = first.getType();
  242.  
  243. 		if (TokenType.INT.equals(type)) {
  244. 			Integer tmpint = Integer.valueOf(token);
  245. 			if (tmpint.intValue() < 1) {
  246. 				throw new SyntaxError(token);
  247. 			}
  248. 			program.put(tmpint, tokens);
  249. 			return 0;
  250. 		} else if (TokenType.NAME.equals(type) == false) {
  251. 			throw new ExcuteError(token);
  252. 		}
  253. 		switch (token) {
  254. 			case "CONT": // プログラムの再開
  255. 			case "EXIT": // インタプリタの終了
  256. 				return -1;
  257. 			case "LIST": // プログラムの表示
  258. 				do_list(tokens);
  259. 				break;
  260. 			case "LOAD": // プログラムのロード
  261. 			case "NEW":  // プログラムと変数の全消去
  262. 			case "RENUM": // プログラムの行番号再割り当て
  263. 				break;
  264. 			case "RUN":  // プログラムの実行
  265. 				do_run(tokens);
  266. 				break;
  267. 			case "SAVE": // プログラムの保存
  268. 				break;
  269. 			default:
  270. 				excute(tokens, 0);
  271. 				break;
  272. 		}
  273. 		System.out.println("Ok");
  274. 		return 0;
  275. 	}
  276.  
  277. 	private void do_list(List<Token> tokens) throws SyntaxError
  278. 	{
  279. 		Integer start = null;
  280. 		Integer end = null;
  281. 		Token first, second, third;
  282. 		Map<Integer, List<Token>> list = null;
  283. 		try {
  284. 			switch (tokens.size()) {
  285. 				case 1:
  286. 					list = program;
  287. 					break;
  288. 				case 2:
  289. 					first = tokens.get(1);
  290. 					if (TokenType.INT.equals(first.getType()) == false) {
  291. 						throw new SyntaxError(tokens ,1);
  292. 					}
  293. 					start = Integer.valueOf(first.getToken());
  294. 					if (start.intValue() < 1) {
  295. 						throw new SyntaxError(tokens ,1);
  296. 					}
  297. 					list = program.tailMap(start);
  298. 					break;
  299. 				case 3:
  300. 					if ("-".equals(tokens.get(1).getToken()) == false) {
  301. 						throw new SyntaxError(tokens ,1);
  302. 					}
  303. 					second = tokens.get(2);
  304. 					if (TokenType.INT.equals(second.getType()) == false) {
  305. 						throw new SyntaxError(tokens ,2);
  306. 					}
  307. 					end = Integer.valueOf(second.getToken());
  308. 					if (end.intValue() < 1) {
  309. 						throw new SyntaxError(tokens ,2);
  310. 					}
  311. 					list = program.headMap(end, true);
  312. 					break;
  313. 				case 4:
  314. 					first = tokens.get(1);
  315. 					if (TokenType.INT.equals(first.getType()) == false) {
  316. 						throw new SyntaxError(tokens ,1);
  317. 					}
  318. 					start = Integer.valueOf(first.getToken());
  319. 					if (start.intValue() < 1) {
  320. 						throw new SyntaxError(tokens ,1);
  321. 					}
  322. 					if ("-".equals(tokens.get(2).getToken()) == false) {
  323. 						throw new SyntaxError(tokens ,2);
  324. 					}
  325. 					third = tokens.get(3);
  326. 					if (TokenType.INT.equals(third.getType()) == false) {
  327. 						throw new SyntaxError(tokens ,3);
  328. 					}
  329. 					end = Integer.valueOf(third.getToken());
  330. 					if (end.intValue() < 1) {
  331. 						throw new SyntaxError(tokens ,3);
  332. 					}
  333. 					list = program.subMap(start, true, end, true);
  334. 					break;
  335. 				default:
  336. 					throw new SyntaxError(tokens, 0);
  337. 			}
  338. 		} catch (SyntaxError er) {
  339. 			throw er;
  340. 		} catch (Exception ex) {
  341. 			throw new ExcuteError(ex);
  342. 		}
  343.  
  344. 		if (list == null) {
  345. 			return;
  346. 		}
  347.  
  348. 		for (Integer key: list.keySet()) {
  349. 			printLine(key, list.get(key));
  350. 		}
  351.  
  352. 	}
  353.  
  354. 	private void do_run(List<Token> tokens) throws SyntaxError
  355. 	{
  356. 		switch (tokens.size()) {
  357. 			case 1:
  358. 				programcounter = program.ceilingKey(Integer.valueOf(1));
  359. 				if (programcounter == null) {
  360. 					throw new SyntaxError("Program is not found");
  361. 				}
  362. 				break;
  363. 			case 2:
  364. 				Token first = tokens.get(1);
  365. 				if (TokenType.INT.equals(first.getType()) == false) {
  366. 					throw new SyntaxError("Illegal Argument");
  367. 				}
  368. 				programcounter = Integer.valueOf(first.getToken());
  369. 				if (programcounter.intValue() < 1) {
  370. 					throw new SyntaxError("Wrong Line Number");
  371. 				}
  372. 				if (program.containsKey(programcounter) == false) {
  373. 					throw new SyntaxError("Not found Line Number");
  374. 				}
  375. 				break;
  376. 			default:
  377. 				throw new SyntaxError("Illegal Arguments");
  378. 		}
  379.  
  380. 		List<Token> line = null;
  381. 		try {
  382. 			while (programcounter != null) {
  383. 				line = program.get(programcounter);
  384. 				excute(line, 1);
  385. 				if (jumpflag == false) {
  386. 					programcounter = program.higherKey(programcounter);
  387. 				} else {
  388. 					jumpflag = false;
  389. 				}
  390. 			}
  391. 		} catch (SyntaxError er) {
  392. 			System.out.println(line);
  393. 			throw er;
  394. 		}
  395.  
  396. 	}
  397.  
  398. 	private int excute(List<Token> tokens, int index) throws SyntaxError
  399. 	{
  400. 		if (index < 0 || index >= tokens.size()) {
  401. 			return tokens.size();
  402. 		}
  403. 		Token first = tokens.get(index);
  404. 		TokenType type = first.getType();
  405.  
  406. 		while (TokenType.COLON.equals(type)) {
  407. 			index++;
  408. 			if (index == tokens.size()) {
  409. 				return index;
  410. 			}
  411. 			first = tokens.get(index);
  412. 			type = first.getType();
  413. 		}
  414.  
  415. 		if (TokenType.NAME.equals(type) == false) {
  416. 			throw new SyntaxError(first.toString());
  417. 		}
  418. 		String cmd = first.getToken();
  419. 		int offset = index;
  420. 		switch (cmd) {
  421. 			case "BASE": // 配列の下限(0/1)の設定
  422. 				offset = cmd_base(tokens, index + 1);
  423. 				break;
  424. 			case "BREAK": // FORループの脱出
  425. 			case "DATA": // データの列挙
  426. 			case "DIM":  // 配列変数の宣言
  427. 			case "ELSE": // IF文のELSE節の開始
  428. 			case "END":  // プログラムの終了
  429. 			case "FILE": // ファイルの割り当て
  430. 			case "FOR":  // 繰り返し
  431. 				break;
  432. 			case "GO":   // GOTOの分割トークン
  433. 				if (index + 2 >= tokens.size()) {
  434. 					throw new SyntaxError(tokens, index);
  435. 				}
  436. 				if ("TO".equals(tokens.get(index + 1).getToken()) == false) {
  437. 					throw new SyntaxError(tokens, index);
  438. 				}
  439. 				offset = cmd_goto(tokens, index + 2);
  440. 				break;
  441. 			case "GOTO": // ジャンプ
  442. 				offset = cmd_goto(tokens, index + 1);
  443. 				break;
  444. 			case "GOSUB": // サブルーチンジャンプ
  445. 				offset = cmd_gosub(tokens, index + 1);
  446. 				break;
  447. 			case "IF":    // 条件節
  448. 			case "INPUT": // キーボードからの値の入力
  449. 				break;
  450. 			case "LET":   // 変数への代入
  451. 				offset = cmd_let(tokens, index + 1);
  452. 				break;
  453. 			case "NEXT":  // FOR文の末端
  454. 			case "PRINT": // 画面へ値を出力
  455. 				break;
  456. 			case "REM":   // コメント行
  457. 				offset = tokens.size();
  458. 				break;
  459. 			case "RESTORE": // データ・ファイルの読み込み位置のリセット
  460. 				break;
  461. 			case "RETURN": // サブルーチンからの脱出
  462. 				offset = cmd_return(tokens, index);
  463. 				break;
  464. 			case "STOP":   // プログラムの中断
  465. 				break;
  466. 			default:
  467. 				offset = cmd_let(tokens, index);
  468. 				break;
  469. 		}
  470. 		return offset;
  471. 	}
  472.  
  473. 	@Override
  474. 	public String toString()
  475. 	{
  476. 		return program.toString().replaceAll("(\\d+=\\[\\[)", "\n$1");
  477. 	}
  478.  
  479. 	private int cmd_goto(List<Token> tokens, int index) throws SyntaxError
  480. 	{
  481. 		if (index >= tokens.size()) {
  482. 			throw new SyntaxError(tokens, index);
  483. 		}
  484. 		if (index + 1 < tokens.size()) {
  485. 			if (TokenType.COLON.equals(tokens.get(index + 1).getType()) == false) {
  486. 				throw new SyntaxError(tokens, index + 1);
  487. 			}
  488. 		}
  489. 		Token first = tokens.get(index);
  490. 		if (TokenType.INT.equals(first.getType()) == false) {
  491. 			throw new SyntaxError(tokens, index);
  492. 		}
  493. 		Integer next = Integer.valueOf(first.getToken());
  494. 		if (program.containsKey(next) == false) {
  495. 			throw new SyntaxError(tokens, index);
  496. 		}
  497. 		programcounter = next;
  498. 		jumpflag = true;
  499. 		return tokens.size();
  500. 	}
  501.  
  502. 	private int cmd_gosub(List<Token> tokens, int index) throws SyntaxError
  503. 	{
  504. 		if (index >= tokens.size()) {
  505. 			throw new SyntaxError(tokens, index);
  506. 		}
  507. 		if (index + 1 < tokens.size()) {
  508. 			if (TokenType.COLON.equals(tokens.get(index + 1).getType()) == false) {
  509. 				throw new SyntaxError(tokens, index + 1);
  510. 			}
  511. 		}
  512. 		Token first = tokens.get(index);
  513. 		if (TokenType.INT.equals(first.getType()) == false) {
  514. 			throw new SyntaxError(tokens, index);
  515. 		}
  516. 		Integer next = Integer.valueOf(first.getToken());
  517. 		if (program.containsKey(next) == false) {
  518. 			throw new SyntaxError(tokens, index);
  519. 		}
  520. 		try {
  521. 			programcounterstack.push(programcounter);
  522. 			programcounter = next;
  523. 			jumpflag = true;
  524. 			return tokens.size();
  525. 		} catch (Exception ex) {
  526. 			throw new ExcuteError(ex);
  527. 		}
  528. 	}
  529.  
  530. 	private int cmd_return(List<Token> tokens, int index) throws SyntaxError
  531. 	{
  532. 		if (index < tokens.size()) {
  533. 			if (TokenType.COLON.equals(tokens.get(index).getType()) == false) {
  534. 				throw new SyntaxError(tokens, index);
  535. 			}
  536. 		}
  537. 		try {
  538. 			Integer back = programcounterstack.pop();
  539. 			programcounter = program.higherKey(back);
  540. 			jumpflag = true;
  541. 			return tokens.size();
  542. 		} catch (Exception ex) {
  543. 			throw new ExcuteError(ex);
  544. 		}
  545. 	}
  546.  
  547.  
  548. 	private int cmd_base(List<Token> tokens, int index) throws SyntaxError
  549. 	{
  550. 		try {
  551. 			Token first = tokens.get(index);
  552. 			if (TokenType.INT.equals(first.getType()) == false) {
  553. 				throw new SyntaxError(tokens, index);
  554. 			}
  555. 			int tmpint = Integer.parseInt(first.getToken());
  556. 			if (tmpint != 0 && tmpint != 1) {
  557. 				throw new SyntaxError(tokens, index + 1);
  558. 			}
  559. 			arraybase = tmpint;
  560. 			return excute(tokens, index + 1);
  561. 		} catch (SyntaxError er) {
  562. 			throw er;
  563. 		} catch (Exception ex) {
  564. 			throw new ExcuteError(ex);
  565. 		}
  566. 	}
  567.  
  568. 	private int cmd_let(List<Token> tokens, int index) throws SyntaxError
  569. 	{
  570. 		try {
  571. 			Token first = tokens.get(index);
  572. 			String name = first.getToken();
  573. 			// if (checkKeyword(name)) // 予約語チェック
  574. 			//     throw new SyntaxError("Wrong variable name: " + name); 
  575. 			index++;
  576. 			if (name.lastIndexOf("$") > 0) {
  577. 				if (strarrs.containsKey(name)) {
  578. 					if (TokenType.OP_BRKT.equals(tokens.get(index).getType()) == false) {
  579. 						throw new SyntaxError(tokens, index);
  580. 					}
  581. 				} else  {
  582. 					if ("=".equals(tokens.get(index).getToken()) == false) {
  583. 						throw new SyntaxError(tokens, index);
  584. 					}
  585. 					index++;
  586. 					// Result result = calc(tokens, index);
  587. 					// if (result.getType() != "STRING")
  588. 					//     throw new ExcuteError();
  589. 					// offset = result.getOffset();
  590. 					// strvars.put(name, result.getStrValue());
  591. 				}
  592. 			} else {
  593. 				if (numarrs.containsKey(name)) {
  594. 					if (TokenType.OP_BRKT.equals(tokens.get(index).getType()) == false) {
  595. 						throw new SyntaxError(tokens, index);
  596. 					}
  597. 				} else  {
  598. 					if ("=".equals(tokens.get(index).getToken()) == false) {
  599. 						throw new SyntaxError(tokens ,index);
  600. 					}
  601. 					// Result result = calc(tokens, index);
  602. 					// if (result.getType() != "NUMBER")
  603. 					//     throw new ExcuteError();
  604. 					// offset = result.getOffset();
  605. 					// numvars.put(name, result.getNumValue());
  606. 				}
  607. 			}
  608. 			// return excute(tokens, index);
  609. 			return tokens.size();
  610. 		} catch (SyntaxError er) {
  611. 			throw er;
  612. 		} catch (Exception ex) {
  613. 			ex.printStackTrace();
  614. 			throw new ExcuteError(tokens.toString());
  615. 		}
  616.  
  617. 	}
  618.  
  619. }
Success #stdin #stdout 0.1s 380288KB
comments (?)
stdin 
00010 LET J4=1
00030 PRINT
00100 BASE 0
00110 LET X=0
00120 LET J=0
00130 LET K=0
00140 X1=0
00150 LET X3=0
00160 LET J9=RND(CLK(J9))
00170 DIM C(7),C$(7),W(100),D(50,50),P(100),I$(100),B(100,6),B$(100)
00180 DIM E(100),F(100),X5(100),X6(100),X2(100),X4(100)
00190 LET G=INT(RND(0)*24+2)
00200 LET H=INT(RND(0)*24+2)
00210 FILE #1="DNG1"
00220 FILE #2="DNG2",#3="DNG3",#4="DNG4",#5="DNG5",#6="DNG6"
00230 RESTORE #4
00240 FILE #7="GMSTR"
00245 RESTORE #7
00250 RESTORE #1
00260 RESTORE #2
00261 RESTORE #3
00262 RESTORE #4
00263 RESTORE #5
00264 RESTORE #6
00270 DATA "STR","DEX","CON","CHAR","WIS","INT","GOLD"
list
run
stdout 
00010 LET J4=1
00030 PRINT
00100 BASE 0
00110 LET X=0
00120 LET J=0
00130 LET K=0
00140 X1=0
00150 LET X3=0
00160 LET J9=RND(CLK(J9))
00170 DIM C(7),C$(7),W(100),D(50,50),P(100),I$(100),B(100,6),B$(100)
00180 DIM E(100),F(100),X5(100),X6(100),X2(100),X4(100)
00190 LET G=INT(RND(0)*24+2)
00200 LET H=INT(RND(0)*24+2)
00210 FILE #1="DNG1"
00220 FILE #2="DNG2",#3="DNG3",#4="DNG4",#5="DNG5",#6="DNG6"
00230 RESTORE #4
00240 FILE #7="GMSTR"
00245 RESTORE #7
00250 RESTORE #1
00260 RESTORE #2
00261 RESTORE #3
00262 RESTORE #4
00263 RESTORE #5
00264 RESTORE #6
00270 DATA "STR","DEX","CON","CHAR","WIS","INT","GOLD"
Ok
Ok
https://ideone.com/mJxVkj
language:
Java (HotSpot 12)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!