Input:
	public static Task parse_json(JsonObject el, AccountMirakel account) {
		Task t = null;
		JsonElement id = el.get("id");
		if (id != null) {
			t = Task.get(id.getAsLong());
		} else {
			id = el.get("uuid");
			if (id != null) {
				t = Task.getByUUID(id.getAsString());
			}
		}
		if (t == null) {
			t = new Task();
		}
		Set<Entry<String, JsonElement>> entries = el.entrySet();
		for (Entry<String, JsonElement> entry : entries) {
			String key = entry.getKey();
			JsonElement val = entry.getValue();
			if (key == null || key.equals("id")) {
				continue;
			}
			if (key.equals("uuid")) {
				t.setUUID(val.getAsString());
			} else if (key.equals("name") || key.equals("description")) {
				t.setName(val.getAsString());
			} else if (key.equals("content")) {
				String content = val.getAsString();
				if (content == null) {
					content = "";
				}
				t.setContent(content);
			} else if (key.equals("priority")) {
				String prioString = val.getAsString().trim();
				if (prioString.equals("L") && t.getPriority() != -1) {
					t.setPriority(-2);
				} else if (prioString.equals("M")) {
					t.setPriority(1);
				} else if (prioString.equals("H")) {
					t.setPriority(2);
				} else if (!prioString.equals("L")) {
					t.setPriority(val.getAsInt());
				}
			} else if(key.equals("progress")) {
				int progress=(int) val.getAsDouble();
				t.setProgress(progress);
			} else if (key.equals("list_id")) {
				ListMirakel list = ListMirakel.getList(val.getAsInt());
				if (list == null) {
					list = SpecialList.firstSpecial().getDefaultList();
				}
				t.setList(list, true);
			} else if (key.equals("project")) {
				ListMirakel list = ListMirakel.findByName(val.getAsString(),
						account);
				if (list == null
						|| list.getAccount().getId() != account.getId()) {
					list = ListMirakel.newList(val.getAsString(),
							ListMirakel.SORT_BY_OPT, account);
				}
				t.setList(list, true);
			} else if (key.equals("created_at")) {
				t.setCreatedAt(val.getAsString().replace(":", ""));
			} else if (key.equals("updated_at")) {
				t.setUpdatedAt(val.getAsString().replace(":", ""));
			} else if (key.equals("entry")) {
				t.setCreatedAt(parseDate(val.getAsString(),
						context.getString(R.string.TWDateFormat)));
			} else if (key.equals("modification")||key.equals("modified")) {
				t.setUpdatedAt(parseDate(val.getAsString(),
						context.getString(R.string.TWDateFormat)));
			} else if (key.equals("done")) {
				t.setDone(val.getAsBoolean());
			} else if (key.equals("status")) {
				String status = val.getAsString();
				if (status.equals("pending")) {
					t.setDone(false);
				} else if (status.equals("deleted")) {
					t.setSyncState(SYNC_STATE.DELETE);
				} else {
					t.setDone(true);
				}
				t.addAdditionalEntry(key, "\"" + val.getAsString() + "\"");
			} else if (key.equals("due")) {
				Calendar due = parseDate(val.getAsString(), "yyyy-MM-dd");
				if (due == null) {
					due = parseDate(val.getAsString(),
							context.getString(R.string.TWDateFormat));
					if (due != null) {
						due.setTimeInMillis(due.getTimeInMillis()
								+ TimeZone.getDefault().getRawOffset());
					}
				}
				t.setDue(due);
			} else if (key.equals("reminder")) {
				Calendar reminder = parseDate(val.getAsString(), "yyyy-MM-dd");
				if (reminder == null) {
					reminder = parseDate(val.getAsString(),
							context.getString(R.string.TWDateFormat));
				}
				t.setReminder(reminder);
			} else if (key.equals("annotations")) {
				String content = "";
				try {
					JsonArray annotations = val.getAsJsonArray();
					boolean first = true;
					for (JsonElement a : annotations) {
						if (first) {
							first = false;
						} else {
							content += "\n";
						}
						content += a.getAsJsonObject().get("description")
								.getAsString();
					}
				} catch (Exception e) {
					Log.e(TAG, "cannot parse json");
				}
				t.setContent(content);
			} else if (key.equals("content")) {
				t.setContent(val.getAsString());
			} else if (key.equals("sync_state")) {
				t.setSyncState(SYNC_STATE.parseInt(val.getAsInt()));
			} else if (key.equals("depends")) {
				t.setDependencies(val.getAsString().split(","));
			} else {
				if (val.isJsonPrimitive()) {
					JsonPrimitive p = (JsonPrimitive) val;
					if (p.isBoolean()) {
						t.addAdditionalEntry(key, val.getAsBoolean() + "");
					} else if (p.isNumber()) {
						t.addAdditionalEntry(key, val.getAsInt() + "");
					} else if (p.isJsonNull()) {
						t.addAdditionalEntry(key, "null");
					} else if (p.isString()) {
						t.addAdditionalEntry(key, "\"" + val.getAsString()
								+ "\"");
					} else {
						Log.w(TAG, "unkown json-type");
					}
				} else if (val.isJsonArray()) {
					JsonArray a = (JsonArray) val;
					String s = "[";
					boolean first = true;
					for (JsonElement e : a) {
						if (e.isJsonPrimitive()) {
							JsonPrimitive p = (JsonPrimitive) e;
							String add;
							if (p.isBoolean()) {
								add = p.getAsBoolean() + "";
							} else if (p.isNumber()) {
								add = p.getAsInt() + "";
							} else if (p.isString()) {
								add = "\"" + p.getAsString() + "\"";
							} else if (p.isJsonNull()) {
								add = "null";
							} else {
								Log.w(TAG, "unkown json-type");
								break;
							}
							s += (first ? "" : ",") + add;
							first = false;
						} else {
							Log.w(TAG, "unkown json-type");
						}
					}
					t.addAdditionalEntry(key, s + "]");
				} else {
					Log.w(TAG, "unkown json-type");
				}
			}
		}
		return t;
	}

Output:
	public static Task parse_json(JsonObject el, AccountMirakel account) {
		Task t = null;
		JsonElement id = el.get("id");
		if (id != null) {
			t = Task.get(id.getAsLong());
		} else {
			id = el.get("uuid");
			if (id != null) {
				t = Task.getByUUID(id.getAsString());
			}
		}
		if (t == null) {
			t = new Task();
		}
		Set<Entry<String, JsonElement>> entries = el.entrySet();
		for (Entry<String, JsonElement> entry : entries) {
			String key = entry.getKey();
			JsonElement val = entry.getValue();
			if (key == null || key.equals("id")) {
				continue;
			}
			if (key.equals("uuid")) {
				t.setUUID(val.getAsString());
			} else if (key.equals("name") || key.equals("description")) {
				t.setName(val.getAsString());
			} else if (key.equals("content")) {
				String content = val.getAsString();
				if (content == null) {
					content = "";
				}
				t.setContent(content);
			} else if (key.equals("priority")) {
				String prioString = val.getAsString().trim();
				if (prioString.equals("L") && t.getPriority() != -1) {
					t.setPriority(-2);
				} else if (prioString.equals("M")) {
					t.setPriority(1);
				} else if (prioString.equals("H")) {
					t.setPriority(2);
				} else if (!prioString.equals("L")) {
					t.setPriority(val.getAsInt());
				}
			} else if(key.equals("progress")) {
				int progress=(int) val.getAsDouble();
				t.setProgress(progress);
			} else if (key.equals("list_id")) {
				ListMirakel list = ListMirakel.getList(val.getAsInt());
				if (list == null) {
					list = SpecialList.firstSpecial().getDefaultList();
				}
				t.setList(list, true);
			} else if (key.equals("project")) {
				ListMirakel list = ListMirakel.findByName(val.getAsString(),
						account);
				if (list == null
						|| list.getAccount().getId() != account.getId()) {
					list = ListMirakel.newList(val.getAsString(),
							ListMirakel.SORT_BY_OPT, account);
				}
				t.setList(list, true);
			} else if (key.equals("created_at")) {
				t.setCreatedAt(val.getAsString().replace(":", ""));
			} else if (key.equals("updated_at")) {
				t.setUpdatedAt(val.getAsString().replace(":", ""));
			} else if (key.equals("entry")) {
				t.setCreatedAt(parseDate(val.getAsString(),
						context.getString(R.string.TWDateFormat)));
			} else if (key.equals("modification")) {
				t.setUpdatedAt(parseDate(val.getAsString(),
						context.getString(R.string.TWDateFormat)));
			} else if (key.equals("modified")) {
				Calendar modification = new GregorianCalendar();
				modification
						.setTimeInMillis(Long.parseLong(val.getAsString()) * 1000);
				t.setUpdatedAt(modification);
			} else if (key.equals("done")) {
				t.setDone(val.getAsBoolean());
			} else if (key.equals("status")) {
				String status = val.getAsString();
				if (status.equals("pending")) {
					t.setDone(false);
				} else if (status.equals("deleted")) {
					t.setSyncState(SYNC_STATE.DELETE);
				} else {
					t.setDone(true);
				}
				t.addAdditionalEntry(key, "\"" + val.getAsString() + "\"");
			} else if (key.equals("due")) {
				Calendar due = parseDate(val.getAsString(), "yyyy-MM-dd");
				if (due == null) {
					due = parseDate(val.getAsString(),
							context.getString(R.string.TWDateFormat));
					if (due != null) {
						due.setTimeInMillis(due.getTimeInMillis()
								+ TimeZone.getDefault().getRawOffset());
					}
				}
				t.setDue(due);
			} else if (key.equals("reminder")) {
				Calendar reminder = parseDate(val.getAsString(), "yyyy-MM-dd");
				if (reminder == null) {
					reminder = parseDate(val.getAsString(),
							context.getString(R.string.TWDateFormat));
				}
				t.setReminder(reminder);
			} else if (key.equals("annotations")) {
				String content = "";
				try {
					JsonArray annotations = val.getAsJsonArray();
					boolean first = true;
					for (JsonElement a : annotations) {
						if (first) {
							first = false;
						} else {
							content += "\n";
						}
						content += a.getAsJsonObject().get("description")
								.getAsString();
					}
				} catch (Exception e) {
					Log.e(TAG, "cannot parse json");
				}
				t.setContent(content);
			} else if (key.equals("content")) {
				t.setContent(val.getAsString());
			} else if (key.equals("sync_state")) {
				t.setSyncState(SYNC_STATE.parseInt(val.getAsInt()));
			} else if (key.equals("depends")) {
				t.setDependencies(val.getAsString().split(","));
			} else {
				if (val.isJsonPrimitive()) {
					JsonPrimitive p = (JsonPrimitive) val;
					if (p.isBoolean()) {
						t.addAdditionalEntry(key, val.getAsBoolean() + "");
					} else if (p.isNumber()) {
						t.addAdditionalEntry(key, val.getAsInt() + "");
					} else if (p.isJsonNull()) {
						t.addAdditionalEntry(key, "null");
					} else if (p.isString()) {
						t.addAdditionalEntry(key, "\"" + val.getAsString()
								+ "\"");
					} else {
						Log.w(TAG, "unkown json-type");
					}
				} else if (val.isJsonArray()) {
					JsonArray a = (JsonArray) val;
					String s = "[";
					boolean first = true;
					for (JsonElement e : a) {
						if (e.isJsonPrimitive()) {
							JsonPrimitive p = (JsonPrimitive) e;
							String add;
							if (p.isBoolean()) {
								add = p.getAsBoolean() + "";
							} else if (p.isNumber()) {
								add = p.getAsInt() + "";
							} else if (p.isString()) {
								add = "\"" + p.getAsString() + "\"";
							} else if (p.isJsonNull()) {
								add = "null";
							} else {
								Log.w(TAG, "unkown json-type");
								break;
							}
							s += (first ? "" : ",") + add;
							first = false;
						} else {
							Log.w(TAG, "unkown json-type");
						}
					}
					t.addAdditionalEntry(key, s + "]");
				} else {
					Log.w(TAG, "unkown json-type");
				}
			}
		}
		return t;
	}


Input:
	public void sync() throws IOException {
		int blocks = 0;
		for (DirectoryEntry dir : entries.values()) {
			Dirent ent = (Dirent) dir;
			log.debug("ent size", ent.getSize());
			int n = ent.numberHeaderBlocks();
			blocks += n;
		}
		long dirPosition = chan.position();
		int blockSize = headerBlockManager.getBlockSize();
		int forHeader = (blocks + DirectoryEntry.SLOTS_PER_ENTRY - 1)/DirectoryEntry.SLOTS_PER_ENTRY;
		log.debug("header blocks needed", forHeader);
		chan.position(dirPosition + (long) forHeader * Dirent.ENTRY_SIZE);
		for (DirectoryEntry dir : entries.values()) {
			Dirent ent = (Dirent) dir;
			if (!ent.isSpecial()) {
				log.debug("wrting ", dir.getFullName(), " at ", chan.position());
				log.debug("ent size", ent.getSize());
				ent.sync(chan);
			}
		}
		long end = (long) blockSize * headerBlockManager.getMaxBlock();
		ByteBuffer buf = ByteBuffer.allocate((int) (end - chan.position()));
		for (int i = 0; i < buf.capacity(); i++)
			buf.put((byte) 0);
		buf.flip();
		chan.write(buf);
		chan.position(dirPosition);
		Dirent ent = (Dirent) entries.values().iterator().next();
		log.debug("ent header size", ent.getSize());
		ent.sync(chan);
	}

Output:
	public void sync() throws IOException {
		int blocks = 0;
		for (DirectoryEntry dir : entries.values()) {
			Dirent ent = (Dirent) dir;
			log.debug("ent size", ent.getSize());
			int n = ent.numberHeaderBlocks();
			blocks += n;
		}
		long dirPosition = chan.position();
		int blockSize = headerBlockManager.getBlockSize();
		int forHeader = (blocks + Dirent.ENTRY_SIZE - 1)/Dirent.ENTRY_SIZE;
		log.debug("header blocks needed", forHeader);
		assert forHeader == 1;
		chan.position(dirPosition + (long) forHeader * Dirent.ENTRY_SIZE);
		for (DirectoryEntry dir : entries.values()) {
			Dirent ent = (Dirent) dir;
			if (!ent.isSpecial()) {
				log.debug("wrting ", dir.getFullName(), " at ", chan.position());
				log.debug("ent size", ent.getSize());
				ent.sync(chan);
			}
		}
		long end = (long) blockSize * headerBlockManager.getMaxBlock();
		ByteBuffer buf = ByteBuffer.allocate((int) (end - chan.position()));
		for (int i = 0; i < buf.capacity(); i++)
			buf.put((byte) 0);
		buf.flip();
		chan.write(buf);
		chan.position(dirPosition);
		Dirent ent = (Dirent) entries.values().iterator().next();
		log.debug("ent header size", ent.getSize());
		ent.sync(chan);
	}


Input:
	public final boolean performFinish() {
		final AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager().getRepositoryConnector(
				this.repository.getKind());
		final String taskId = getTaskId();
		try {
			getContainer().run(true, false, new IRunnableWithProgress() {
				public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
					monitor.beginTask("Retrieving task...", IProgressMonitor.UNKNOWN);
					try {
						newTask = connector.createTaskFromExistingKey(repository, taskId, null);
						if (newTask instanceof AbstractRepositoryTask) {
							TasksUiPlugin.getSynchronizationManager().synchronize(connector, (AbstractRepositoryTask)newTask, true, null);
						}
					} catch (Exception e) {
						throw new InvocationTargetException(e);
					} finally {
						monitor.done();
					}
				}
			});
		} catch (InvocationTargetException e) {
			String message = e.getCause() != null ? e.getCause().getMessage() : "None provided";
			MessageDialog.openWarning(this.getShell(), "Add Existing Task Failed",
					"Unable to retrieve existing task from repository, error was: \n\n" + message);
		} catch (InterruptedException e) {
			return true;
		}
		if (newTask != null && TaskListView.getFromActivePerspective() != null) {
			Object selectedObject = ((IStructuredSelection) TaskListView.getFromActivePerspective().getViewer()
					.getSelection()).getFirstElement();
			if (selectedObject instanceof TaskCategory) {
				TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(((TaskCategory) selectedObject),
						newTask);
			} else {
				TasksUiPlugin.getTaskListManager().getTaskList().moveToRoot(newTask);
			}
			if (TaskListView.getFromActivePerspective() != null) {
				TaskListView.getFromActivePerspective().getViewer().setSelection(new StructuredSelection(newTask));
			}
			TaskUiUtil.openEditor(newTask, false);
		} else {
			MessageDialog.openWarning(this.getShell(), "Add Existing Task Failed",
					"Unable to retrieve task from repository.");
		}
		return true;
	}

Output:
	public final boolean performFinish() {
		final AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager().getRepositoryConnector(
				this.repository.getKind());
		final String taskId = getTaskId();
		try {
			getContainer().run(true, false, new IRunnableWithProgress() {
				public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
					monitor.beginTask("Retrieving task...", IProgressMonitor.UNKNOWN);
					try {
						newTask = connector.createTaskFromExistingKey(repository, taskId, null);
						if (newTask instanceof AbstractRepositoryTask) {
							TasksUiPlugin.getSynchronizationManager().synchronize(connector, (AbstractRepositoryTask)newTask, true, null);
						}
					} catch (Exception e) {
						throw new InvocationTargetException(e);
					} finally {
						monitor.done();
					}
				}
			});
		} catch (InvocationTargetException e) {
			String message = e.getCause() != null ? e.getCause().getMessage() : "None provided";
			MessageDialog.openWarning(this.getShell(), "Add Existing Task Failed",
					"Unable to retrieve existing task from repository, error was: \n\n" + message);
			return false;
		} catch (InterruptedException e) {
			return true;
		}
		if (newTask != null && TaskListView.getFromActivePerspective() != null) {
			Object selectedObject = ((IStructuredSelection) TaskListView.getFromActivePerspective().getViewer()
					.getSelection()).getFirstElement();
			if (selectedObject instanceof TaskCategory) {
				TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(((TaskCategory) selectedObject),
						newTask);
			} else {
				TasksUiPlugin.getTaskListManager().getTaskList().moveToRoot(newTask);
			}
			if (TaskListView.getFromActivePerspective() != null) {
				TaskListView.getFromActivePerspective().getViewer().setSelection(new StructuredSelection(newTask));
			}
			TaskUiUtil.openEditor(newTask, false);
		} else {
			MessageDialog.openWarning(this.getShell(), "Add Existing Task Failed",
					"Unable to retrieve task from repository.");
		}
		return true;
	}


Input:
	protected void processCommand(Command c) {
		Map response = null, read = null;
		long start;
		long maxwait = 10000;
		try {
			emptyRead();
			response = (Map)connection.execute("session.meterpreter_write", new Object[] { session, Base64.encode(c.text) });
			if (c.text.startsWith("cd "))
				return;
			if (c.text.startsWith("rm "))
				return;
			if (c.text.equals("shell\n") || c.text.equals("exit\n"))
				return;
			read = readResponse();
			start = System.currentTimeMillis();
			while ("".equals(read.get("data")) || read.get("data").toString().startsWith("[-] Error running command read")) {
				if ((System.currentTimeMillis() - start) > maxwait) {
					return;
				}
				Thread.sleep(100);
				read = readResponse();
			}
			fireEvent(c, read);
			Thread.sleep(50);
			read = readResponse();
			while (!"".equals(read.get("data"))) {
				fireEvent(c, read);
				read = readResponse();
			}
		}
		catch (Exception ex) {
			System.err.println(session + " -> " + c.text + " ( " + response + ")");
			ex.printStackTrace();
		}
	}

Output:
	protected void processCommand(Command c) {
		Map response = null, read = null;
		long start;
		long maxwait = 12000;
		try {
			emptyRead();
			response = (Map)connection.execute("session.meterpreter_write", new Object[] { session, Base64.encode(c.text) });
			if (c.text.startsWith("cd "))
				return;
			if (c.text.startsWith("rm "))
				return;
			if (c.text.equals("shell\n") || c.text.equals("exit\n"))
				return;
			read = readResponse();
			start = System.currentTimeMillis();
			while ("".equals(read.get("data")) || read.get("data").toString().startsWith("[-] Error running command read")) {
				if ((System.currentTimeMillis() - start) > maxwait) {
					System.err.println("(" + session + ") - '" + c.text + "' - timed out");
					return;
				}
				Thread.sleep(100);
				read = readResponse();
			}
			fireEvent(c, read);
			Thread.sleep(50);
			read = readResponse();
			while (!"".equals(read.get("data"))) {
				fireEvent(c, read);
				read = readResponse();
			}
		}
		catch (Exception ex) {
			System.err.println(session + " -> " + c.text + " ( " + response + ")");
			ex.printStackTrace();
		}
	}


Input:
    public static String byteArrayToHex(byte[] array, int length, long arrayOffset) {
        if (array == null) {
            return "";
        }
        else {
            StringBuilder outputStringBuilder = new StringBuilder();
            for (int curOffset = 0; curOffset < length; curOffset += 16) {
                int lineLen = 16;
                if (length - curOffset < 16) {
                    lineLen = length - curOffset;
                }
                outputStringBuilder.append(String.format("0x%08x: ", arrayOffset + curOffset));
                for (int i = 0; i < 16; i++) {
                    if (i < lineLen) {
                        int v = array[curOffset + i] & 0xFF;
                        outputStringBuilder.append(hexArray[v >>> 4]);
                        outputStringBuilder.append(hexArray[v & 0x0F]);
                    }
                    else {
                        outputStringBuilder.append("  ");
                    }
                    if (true) {
                        outputStringBuilder.append(" ");
                        if (i % 4 == 3) {
                            outputStringBuilder.append(" ");
                        }
                        if (i == 7) {
                            outputStringBuilder.append(" ");
                        }
                    }
                    else {
                        if (i % 2 == 1) {
                            outputStringBuilder.append(" ");
                        }
                    }
                }
                outputStringBuilder.append("  ");
                String ascii = new String(array, curOffset, lineLen);
                for (int i = 0; i < 16; i++) {
                    char c = ' ';
                    if (i < lineLen) {
                        c = ascii.charAt(i);
                        int dec = (int) c;
                        if (dec < 32 || dec > 126) {
                            c = '.';
                        }
                    }
                    outputStringBuilder.append(c);
                }
                outputStringBuilder.append("\n");
            }
            return outputStringBuilder.toString();
        }
    }

Output:
    public static String byteArrayToHex(byte[] array, int length, long arrayOffset) {
        if (array == null) {
            return "";
        }
        else {
            StringBuilder outputStringBuilder = new StringBuilder();
            for (int curOffset = 0; curOffset < length; curOffset += 16) {
                int lineLen = 16;
                if (length - curOffset < 16) {
                    lineLen = length - curOffset;
                }
                outputStringBuilder.append(String.format("0x%08x: ", arrayOffset + curOffset));
                for (int i = 0; i < 16; i++) {
                    if (i < lineLen) {
                        int v = array[curOffset + i] & 0xFF;
                        outputStringBuilder.append(hexArray[v >>> 4]);
                        outputStringBuilder.append(hexArray[v & 0x0F]);
                    }
                    else {
                        outputStringBuilder.append("  ");
                    }
                    if (true) {
                        outputStringBuilder.append(" ");
                        if (i % 4 == 3) {
                            outputStringBuilder.append(" ");
                        }
                        if (i == 7) {
                            outputStringBuilder.append(" ");
                        }
                    }
                    else {
                        if (i % 2 == 1) {
                            outputStringBuilder.append(" ");
                        }
                    }
                }
                outputStringBuilder.append("  ");
                String ascii = new String(array, curOffset, lineLen, java.nio.charset.StandardCharsets.US_ASCII);
                for (int i = 0; i < 16; i++) {
                    char c = ' ';
                    if (i < ascii.length()) {
                        c = ascii.charAt(i);
                        int dec = (int) c;
                        if (dec < 32 || dec > 126) {
                            c = '.';
                        }
                    }
                    outputStringBuilder.append(c);
                }
                outputStringBuilder.append("\n");
            }
            return outputStringBuilder.toString();
        }
    }


Input:
    public void testSensorOperations() {
        final SensorManager mSensorManager =
            (SensorManager) getContext().getSystemService(Context.SENSOR_SERVICE);
        List<Sensor> sensors = mSensorManager.getSensorList(Sensor.TYPE_ALL);
        assertNotNull(sensors);
        Sensor sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        assertEquals(Sensor.TYPE_ACCELEROMETER, sensor.getType());
        assertSensorValues(sensor);
        sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
        assertEquals(Sensor.TYPE_MAGNETIC_FIELD, sensor.getType());
        assertSensorValues(sensor);
        sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);
        assertEquals(Sensor.TYPE_ORIENTATION, sensor.getType());
        assertSensorValues(sensor);
        sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_TEMPERATURE);
        assertEquals(Sensor.TYPE_TEMPERATURE, sensor.getType());
        assertSensorValues(sensor);
    }

Output:
    public void testSensorOperations() {
        final SensorManager mSensorManager =
            (SensorManager) getContext().getSystemService(Context.SENSOR_SERVICE);
        List<Sensor> sensors = mSensorManager.getSensorList(Sensor.TYPE_ALL);
        assertNotNull(sensors);
        Sensor sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        assertEquals(Sensor.TYPE_ACCELEROMETER, sensor.getType());
        assertSensorValues(sensor);
        sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
        assertEquals(Sensor.TYPE_MAGNETIC_FIELD, sensor.getType());
        assertSensorValues(sensor);
        sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);
        assertEquals(Sensor.TYPE_ORIENTATION, sensor.getType());
        assertSensorValues(sensor);
        sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_TEMPERATURE);
        if (sensor != null) {
            assertEquals(Sensor.TYPE_TEMPERATURE, sensor.getType());
            assertSensorValues(sensor);
        }
    }


Input:
	public void execute(Map p) {
		this.destination = MathUtil.getPuntDesti(this.laser.position.toPoint(), this.destination, 2000f);
		this.laser.lastParringJedi = jedi;
		this.laser.jumps--;
		super.execute(p);
		jedi.forceStopMovement();
		jedi.animateParryLaser(this.destination.clone());
	}

Output:
	public void execute(Map p) {
		this.destination = MathUtil.getPuntDesti(this.laser.position.toPoint(), this.destination, 2000f);
		this.laser.lastParringJedi = jedi;
		this.laser.jumps--;
		super.execute(p);
		jedi.forceStopMovement();
		jedi.animateParryLaser(this.laser.position.toPoint());
	}


Input:
	public static ArrayList<AwfulThread> parseForumThreads(TagNode aResponse) throws Exception {
		long startTime = System.currentTimeMillis();
        ArrayList<AwfulThread> result = new ArrayList<AwfulThread>();
        TagNode[] threads = aResponse.getElementsByAttValue("class", "thread", true, true);
		for(TagNode node : threads){
            AwfulThread thread = new AwfulThread();
            try {
                String threadId = node.getAttributeByName("id");
                thread.setThreadId(threadId.replaceAll("thread", ""));
            } catch (NullPointerException e) {
                e.printStackTrace();
                continue;
            }
            	TagNode[] tarThread = node.getElementsByAttValue("class", "thread_title", true, true);
            	TagNode[] tarUser = node.getElementsByAttValue("class", "author", true, true);
                Object[] nodeList;
                if (tarThread.length > 0) {
                    thread.setTitle(((TagNode) tarThread[0]).getText().toString().trim());
                }
                TagNode[] tarSticky = node.getElementsByAttValue("class", "title title_sticky", true, true);
                if (tarSticky.length > 0) {
                    thread.setSticky(true);
                } else {
                    thread.setSticky(false);
                }
                TagNode[] tarIcon = node.getElementsByAttValue("class", "icon", true, true);
                if (tarIcon.length > 0 && tarIcon[0].getChildTags().length >0) {
                    thread.setIcon(tarIcon[0].getChildTags()[0].getAttributeByName("src"));
                }
                if (tarUser.length > 0) {
                    thread.setAuthor(tarUser[0].getText().toString().trim());
                }
                TagNode[] tarCount = node.getElementsByAttValue("class", "count", true, true);
                if (tarCount.length > 0 && tarCount[0].getChildTags().length >0) {
                    thread.setUnreadCount(Integer.parseInt(
                    		tarCount[0].getChildTags()[0].getText().toString().trim()));
                } else {
                	TagNode[] tarXCount = node.getElementsByAttValue("class", "x", true, true);
					if (tarXCount.length > 0) {
						thread.setUnreadCount(0);
					} else {
						thread.setUnreadCount(-1);
					}
                }
                result.add(thread);
        }
        Log.e("AwfulThread", "Process Time: "+(System.currentTimeMillis()-startTime));
        return result;
    }

Output:
	public static ArrayList<AwfulThread> parseForumThreads(TagNode aResponse) throws Exception {
		long startTime = System.currentTimeMillis();
        ArrayList<AwfulThread> result = new ArrayList<AwfulThread>();
        TagNode[] threads = aResponse.getElementsByAttValue("id", "forum", true, true);
        TagNode[] tbody = threads[0].getElementsByName("tbody", false);
		for(TagNode node : tbody[0].getChildTags()){
            AwfulThread thread = new AwfulThread();
            try {
                String threadId = node.getAttributeByName("id");
                thread.setThreadId(threadId.replaceAll("thread", ""));
            } catch (NullPointerException e) {
                e.printStackTrace();
                continue;
            }
            	TagNode[] tarThread = node.getElementsByAttValue("class", "thread_title", true, true);
            	TagNode[] tarUser = node.getElementsByAttValue("class", "author", true, true);
                Object[] nodeList;
                if (tarThread.length > 0) {
                    thread.setTitle(((TagNode) tarThread[0]).getText().toString().trim());
                }
                TagNode[] tarSticky = node.getElementsByAttValue("class", "title title_sticky", true, true);
                if (tarSticky.length > 0) {
                    thread.setSticky(true);
                } else {
                    thread.setSticky(false);
                }
                TagNode[] tarIcon = node.getElementsByAttValue("class", "icon", true, true);
                if (tarIcon.length > 0 && tarIcon[0].getChildTags().length >0) {
                    thread.setIcon(tarIcon[0].getChildTags()[0].getAttributeByName("src"));
                }
                if (tarUser.length > 0) {
                    thread.setAuthor(tarUser[0].getText().toString().trim());
                }
                TagNode[] tarCount = node.getElementsByAttValue("class", "count", true, true);
                if (tarCount.length > 0 && tarCount[0].getChildTags().length >0) {
                    thread.setUnreadCount(Integer.parseInt(
                    		tarCount[0].getChildTags()[0].getText().toString().trim()));
                } else {
                	TagNode[] tarXCount = node.getElementsByAttValue("class", "x", true, true);
					if (tarXCount.length > 0) {
						thread.setUnreadCount(0);
					} else {
						thread.setUnreadCount(-1);
					}
                }
                result.add(thread);
        }
        Log.e("AwfulThread", "Process Time: "+(System.currentTimeMillis()-startTime));
        return result;
    }


Input:
	public boolean sendPluginMessage(Player player, String message){
		if(player == null || message == null){
			return false;
		}
		if(!player.getListeningPluginChannels().contains("SimpleNotice")){
			return false;
		}
		try{
			player.sendPluginMessage(AntiShare.getInstance(), "SimpleNotice", message.getBytes("UTF-8"));
			return true;
		}catch(Exception e){
			AntiShare.getInstance().getMessenger().log("AntiShare encountered and error. Please report this to turt2live.", Level.SEVERE, LogType.ERROR);
			AntiShare.getInstance().getMessenger().log("Please see " + ErrorLog.print(e) + " for the full error.", Level.SEVERE, LogType.ERROR);
			return false;
		}
	}

Output:
	public boolean sendPluginMessage(Player player, String message){
		if(player == null || message == null){
			return false;
		}
		if(!player.getListeningPluginChannels().contains("SimpleNotice")){
			return false;
		}
		try{
			player.sendPluginMessage(AntiShare.getInstance(), "SimpleNotice", message.getBytes());
			return true;
		}catch(Exception e){
			AntiShare.getInstance().getMessenger().log("AntiShare encountered and error. Please report this to turt2live.", Level.SEVERE, LogType.ERROR);
			AntiShare.getInstance().getMessenger().log("Please see " + ErrorLog.print(e) + " for the full error.", Level.SEVERE, LogType.ERROR);
			return false;
		}
	}


Input:
	public View(Window window, boolean offscreen, boolean isSharedUniverse)
	{
		super(getPreferredConfiguration(window), offscreen);
		if(offscreen)
		{
			getScreen3D().setPhysicalScreenWidth(0.0254/90.0 * 1600);
			getScreen3D().setPhysicalScreenHeight(0.0254/90.0 * 1200);
		}
		if(isSharedUniverse)
		{
			if(sharedUniverse==null)
			{
				sharedUniverse=new SimpleUniverse(this);
				universe=View.sharedUniverse;
				viewingPlatform=universe.getViewingPlatform();
				universe.addBranchGraph(
					createLights(new BoundingSphere(new Point3d(),Double.MAX_VALUE)));
			}
			else
			{
				universe=View.sharedUniverse;
				viewingPlatform=createViewingPlatform();
				sharedUniverse.getLocale().addBranchGraph(viewingPlatform);
			}
		}
		else
		{
			universe=new SimpleUniverse(this);
			viewingPlatform=universe.getViewingPlatform();
			universe.addBranchGraph(createLights(new BoundingSphere(new Point3d(),Double.MAX_VALUE)));
		}
		orbit.setCapability(Node.ALLOW_BOUNDS_WRITE);
		viewingPlatform.setViewPlatformBehavior(orbit);
		originAxisSwitch.setCapability(Switch.ALLOW_SWITCH_READ);
		originAxisSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);
		fixedAxisSwitch.setCapability(Switch.ALLOW_SWITCH_READ);
		fixedAxisSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);
		fixedAxisTransformGroup.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
		createAxis(originAxisTransformGroup);
		originAxisSwitch.addChild(originAxisTransformGroup);
		ViewSpecificGroup vsp=new ViewSpecificGroup();
		vsp.addView(getView());
		vsp.addChild(originAxisSwitch);
		axisBranchGroup.addChild(vsp);
		universe.addBranchGraph(axisBranchGroup);
		createClipBranchGroup();
		createWidgetsBranchGroup();
		createUnClipWidgetsBranchGroup();
		final TransformGroup tg=new TransformGroup();
		tg.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
		tg.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
		Transform3D t3d=new Transform3D();
		t3d.set(new Vector3d(-4, -4, -40));
		createAxis(fixedAxisTransformGroup);
		tg.setTransform(t3d);
		tg.addChild(fixedAxisTransformGroup);
		fixedAxisSwitch.addChild(tg);
		PlatformGeometry pg=new PlatformGeometry();
		vsp=new ViewSpecificGroup();
		vsp.addView(getView());
		vsp.addChild(fixedAxisSwitch);
		pg.addChild(vsp);
		axisBehavior=new AxisBehavior(fixedAxisTransformGroup,
			viewingPlatform.getViewPlatformTransform());
		pg.addChild(axisBehavior);
		viewingPlatform.setPlatformGeometry(pg);
		addComponentListener(new ComponentAdapter()
		{
			private Transform3D myT3d=new Transform3D();
			public void componentResized(ComponentEvent e)
			{
				tg.getTransform(myT3d);
				myT3d.set(new Vector3d(-4, -4*((float)getHeight())/getWidth(), -40));
				tg.setTransform(myT3d);
			}
		});
		getView().setFieldOfView(Math.PI/12);
		getView().setFrontClipPolicy(javax.media.j3d.View.PHYSICAL_EYE);
		getView().setBackClipPolicy(javax.media.j3d.View.PHYSICAL_EYE);
		zoomTo(0,0,0,1.0f);
		addKeyListener(new PAKeyListener());
    }

Output:
	public View(Window window, boolean offscreen, boolean isSharedUniverse)
	{
		super(getPreferredConfiguration(window), offscreen);
		if(offscreen)
		{
			getScreen3D().setPhysicalScreenWidth(0.0254/90.0 * 1600);
			getScreen3D().setPhysicalScreenHeight(0.0254/90.0 * 1200);
		}
		if(isSharedUniverse)
		{
			if(sharedUniverse==null)
			{
				sharedUniverse=new SimpleUniverse(this);
				universe=View.sharedUniverse;
				viewingPlatform=universe.getViewingPlatform();
				universe.addBranchGraph(
					createLights(new BoundingSphere(new Point3d(),Double.MAX_VALUE)));
			}
			else
			{
				universe=View.sharedUniverse;
				viewingPlatform=createViewingPlatform();
				sharedUniverse.getLocale().addBranchGraph(viewingPlatform);
			}
		}
		else
		{
			universe=new SimpleUniverse(this);
			viewingPlatform=universe.getViewingPlatform();
			universe.addBranchGraph(createLights(new BoundingSphere(new Point3d(),Double.MAX_VALUE)));
		}
		orbit.setCapability(Node.ALLOW_BOUNDS_WRITE);
		viewingPlatform.setViewPlatformBehavior(orbit);
		originAxisSwitch.setCapability(Switch.ALLOW_SWITCH_READ);
		originAxisSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);
		fixedAxisSwitch.setCapability(Switch.ALLOW_SWITCH_READ);
		fixedAxisSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);
		fixedAxisTransformGroup.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
		createAxis(originAxisTransformGroup);
		originAxisSwitch.addChild(originAxisTransformGroup);
		ViewSpecificGroup vsp=new ViewSpecificGroup();
		vsp.addView(getView());
		vsp.addChild(originAxisSwitch);
		axisBranchGroup.addChild(vsp);
		universe.addBranchGraph(axisBranchGroup);
		createClipBranchGroup();
		createWidgetsBranchGroup();
		createUnClipWidgetsBranchGroup();
		final TransformGroup tg=new TransformGroup();
		tg.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
		tg.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
		Transform3D t3d=new Transform3D();
		t3d.set(new Vector3d(-4, -4, -40));
		createAxis(fixedAxisTransformGroup);
		tg.setTransform(t3d);
		tg.addChild(fixedAxisTransformGroup);
		fixedAxisSwitch.addChild(tg);
		PlatformGeometry pg=new PlatformGeometry();
		vsp=new ViewSpecificGroup();
		vsp.addView(getView());
		vsp.addChild(fixedAxisSwitch);
		pg.addChild(vsp);
		axisBehavior=new AxisBehavior(fixedAxisTransformGroup,
			viewingPlatform.getViewPlatformTransform());
		pg.addChild(axisBehavior);
		viewingPlatform.setPlatformGeometry(pg);
		addComponentListener(new ComponentAdapter()
		{
			private Transform3D myT3d=new Transform3D();
			public void componentResized(ComponentEvent e)
			{
				if(getWidth()!=0)
				{
					tg.getTransform(myT3d);
					myT3d.set(new Vector3d(-4, -4*((float)getHeight())/getWidth(), -40));
					tg.setTransform(myT3d);
				}
			}
		});
		getView().setFieldOfView(Math.PI/12);
		getView().setFrontClipPolicy(javax.media.j3d.View.PHYSICAL_EYE);
		getView().setBackClipPolicy(javax.media.j3d.View.PHYSICAL_EYE);
		zoomTo(0,0,0,1.0f);
		addKeyListener(new PAKeyListener());
    }


Input:
	public double getV(int index, State qj) {
		assert(index >= 1);
		assert(index-1 < outputSencence.size());
		double cachedValue = checkCache(index, qj);
		if (cachedValue != -1)
			return cachedValue;
		if (index == 1) {
			double probability;
			probability = stateCollection.startState().nextStateProbability(qj);
			probability *= qj.wordEmittingProbability(new Word(outputSencence.get(0)));
			addToCache(index, qj, probability);
			return probability;
		}
		double max = 0;
		for (State qi : stateCollection.states.values()) {
			double value;
			value = getV(index - 1, qj);
			value *= qi.nextStateProbability(qj);
			value *= qj.wordEmittingProbability(new Word(outputSencence.get(index - 1)));
			if (value > max) {
				max = value;
			}
		}
		addToCache(index, qj, max);
		return max;
	}

Output:
	public double getAlpha(int index, State qj) {
		assert(index >= 1);
		assert(index-1 < outputSencence.size());
		double cachedValue = checkCache(index, qj);
		if (cachedValue != -1)
			return cachedValue;
		if (index == 1) {
			double probability;
			probability = stateCollection.startState().nextStateProbability(qj);
			probability *= qj.wordEmittingProbability(new Word(outputSencence.get(0)));
			addToCache(index, qj, probability);
			return probability;
		}
		double sum = 0;
		for (State qi : stateCollection.states.values()) {
			double value;
			value = getAlpha(index - 1, qj);
			value *= qi.nextStateProbability(qj);
			value *= qj.wordEmittingProbability(new Word(outputSencence.get(index - 1)));
			sum += value;
		}
		addToCache(index, qj, sum);
		return sum;
	}


Input:
	private void calculateRotationalAxis(Matrix rotation, Atom translation,
			double c) {
		double sum=0;
		double[] rotAx = new double[3];
		for(int i=0;i<3;i++) {
			rotAx[i] = Math.sqrt(rotation.get(i, i)-c);
			sum+=rotAx[i]*rotAx[i];
		}
		for(int i=0;i<3;i++) {
			rotAx[i] /= Math.sqrt(sum);
		}
		double d0 = rotation.get(2,1)-rotation.get(1,2);
		double d1 = rotation.get(0,2)-rotation.get(2,0);
		double d2 = rotation.get(1,0)-rotation.get(0,1);
		double s12 = rotation.get(2,1)+rotation.get(1,2);
		double s02 = rotation.get(0,2)+rotation.get(2,0);
		double s01 = rotation.get(1,0)+rotation.get(0,1);
		if( Math.abs(d0) < Math.abs(d1) ) {
			if( Math.abs(d1) < Math.abs(d2) ) {
				if(d2>=0){
					if( s02 < 0 ) rotAx[0] = -rotAx[0];
					if( s12 < 0 ) rotAx[1] = -rotAx[1];
				} else {
					rotAx[2] = -rotAx[2];
					if( s02 >= 0 ) rotAx[0] = -rotAx[0];
					if( s12 >= 0 ) rotAx[1] = -rotAx[1];
				}
			} else {
				if(d1>=0) {
					if( s01 < 0) rotAx[0] = -rotAx[0];
					if( s12 < 0) rotAx[2] = -rotAx[2];
				} else {
					rotAx[1] = -rotAx[1];
					if( s01 >= 0) rotAx[0] = -rotAx[0];
					if( s12 >= 0) rotAx[2] = -rotAx[2];
				}
			}
		} else {
			if(d0>=0) {
				if( s01 < 0 ) rotAx[0] = -rotAx[0];
				if( s02 < 0 ) rotAx[2] = -rotAx[2];
			} else {
				rotAx[0] = -rotAx[0];
				if( s01 >= 0 ) rotAx[0] = -rotAx[0];
				if( s02 >= 0 ) rotAx[2] = -rotAx[2];
			}
		}
		rotationAxis = new AtomImpl();
		rotationAxis.setCoords(rotAx);
		double dotProduct = Calc.skalarProduct(rotationAxis, translation);
		screwTranslation = Calc.scale(rotationAxis, dotProduct);
		otherTranslation = Calc.subtract(translation, screwTranslation);
		Atom hypot = Calc.vectorProduct(otherTranslation,rotationAxis);
		Calc.scaleEquals(hypot,.5/Math.tan(theta/2.0));
		rotationPos = Calc.scaleAdd(.5,otherTranslation, hypot);
	}

Output:
	private void calculateRotationalAxis(Matrix rotation, Atom translation,
			double c) {
		double sum=0;
		double[] rotAx = new double[3];
		for(int i=0;i<3;i++) {
			rotAx[i] = Math.sqrt(rotation.get(i, i)-c);
			sum+=rotAx[i]*rotAx[i];
		}
		for(int i=0;i<3;i++) {
			rotAx[i] /= Math.sqrt(sum);
		}
		double d0 = rotation.get(2,1)-rotation.get(1,2);
		double d1 = rotation.get(0,2)-rotation.get(2,0);
		double d2 = rotation.get(1,0)-rotation.get(0,1);
		double s12 = rotation.get(2,1)+rotation.get(1,2);
		double s02 = rotation.get(0,2)+rotation.get(2,0);
		double s01 = rotation.get(1,0)+rotation.get(0,1);
		if( Math.abs(d0) < Math.abs(d1) ) {
			if( Math.abs(d1) < Math.abs(d2) ) {
				if(d2>=0){
					if( s02 < 0 ) rotAx[0] = -rotAx[0];
					if( s12 < 0 ) rotAx[1] = -rotAx[1];
				} else {
					rotAx[2] = -rotAx[2];
					if( s02 >= 0 ) rotAx[0] = -rotAx[0];
					if( s12 >= 0 ) rotAx[1] = -rotAx[1];
				}
			} else {
				if(d1>=0) {
					if( s01 < 0) rotAx[0] = -rotAx[0];
					if( s12 < 0) rotAx[2] = -rotAx[2];
				} else {
					rotAx[1] = -rotAx[1];
					if( s01 >= 0) rotAx[0] = -rotAx[0];
					if( s12 >= 0) rotAx[2] = -rotAx[2];
				}
			}
		} else {
			if( Math.abs(d0) < Math.abs(d2) ) {
				if(d2>=0){
					if( s02 < 0 ) rotAx[0] = -rotAx[0];
					if( s12 < 0 ) rotAx[1] = -rotAx[1];
				} else {
					rotAx[2] = -rotAx[2];
					if( s02 >= 0 ) rotAx[0] = -rotAx[0];
					if( s12 >= 0 ) rotAx[1] = -rotAx[1];
				}
			} else {
				if(d0>=0) {
					if( s01 < 0 ) rotAx[1] = -rotAx[1];
					if( s02 < 0 ) rotAx[2] = -rotAx[2];
				} else {
					rotAx[0] = -rotAx[0];
					if( s01 >= 0 ) rotAx[1] = -rotAx[1];
					if( s02 >= 0 ) rotAx[2] = -rotAx[2];
				}
			}
		}
		rotationAxis = new AtomImpl();
		rotationAxis.setCoords(rotAx);
		double dotProduct = Calc.skalarProduct(rotationAxis, translation);
		screwTranslation = Calc.scale(rotationAxis, dotProduct);
		otherTranslation = Calc.subtract(translation, screwTranslation);
		Atom hypot = Calc.vectorProduct(otherTranslation,rotationAxis);
		Calc.scaleEquals(hypot,.5/Math.tan(theta/2.0));
		rotationPos = Calc.scaleAdd(.5,otherTranslation, hypot);
	}


Input:
    public void copySubstractingFieldFromLowerInstance(final DataDefinition technologyOperationComponentDD,
            final Entity technologyOperationComponent) {
        Entity operation = technologyOperationComponent.getBelongsToField(OPERATION);
        technologyOperationComponent.setField(IS_SUBCONTRACTING, operation.getBooleanField(IS_SUBCONTRACTING));
    }

Output:
    public void copySubstractingFieldFromLowerInstance(final DataDefinition technologyOperationComponentDD,
            final Entity technologyOperationComponent) {
        Entity operation = technologyOperationComponent.getBelongsToField(OPERATION);
        if (operation != null) {
            technologyOperationComponent.setField(IS_SUBCONTRACTING, operation.getBooleanField(IS_SUBCONTRACTING));
        }
    }


Input:
	protected void initUniforms()
	{
		this.addUniform("tColor", new Uniform(Uniform.TYPE.T ));
		this.addUniform("tDepth", new Uniform(Uniform.TYPE.T ));
		this.addUniform("focus", new Uniform(Uniform.TYPE.F, 1.0));
		this.addUniform("aspect", new Uniform(Uniform.TYPE.F, 1.0));
		this.addUniform("aperture", new Uniform(Uniform.TYPE.F, 0.025));
		this.addUniform("maxblur", new Uniform(Uniform.TYPE.I, true));
	}

Output:
	protected void initUniforms()
	{
		this.addUniform("tColor", new Uniform(Uniform.TYPE.T ));
		this.addUniform("tDepth", new Uniform(Uniform.TYPE.T ));
		this.addUniform("focus", new Uniform(Uniform.TYPE.F, 1.0));
		this.addUniform("aspect", new Uniform(Uniform.TYPE.F, 1.0));
		this.addUniform("aperture", new Uniform(Uniform.TYPE.F, 0.025));
		this.addUniform("maxblur", new Uniform(Uniform.TYPE.F, 1.0));
	}