``````function sortUsers(a, b) {
return a.last_name.localeCompare(b.last_name) * -1;
}``````
``````if (cookiesBannerHeight !== 0 && isMobile) {
style = {
}
}
``````
``````public void Method1(Enum foo)
{
if (GetCondition1(foo))
{
doSomething();
}
}

private bool GetCondition1(Enum foo)
{
if (foo == Enum.Value1)
return true;

return false;
}``````
``````
// enum - full enumeration of knapsack solutions
// (C) Joshua Knowles

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>

FILE *fp;  // file pointer for reading the input files
int Capacity;     // capacity of the knapsack (total weight that can be stored)
int Nitems;    // number of items available
int *item_weights;  // vector of item weights
int *item_values;  // vector of item profits or values
int *temp_indexes;  // list of temporary item indexes for sorting items by value/weight
int QUIET=0; // this can be set to 1 to suppress output

extern void print_instance();
extern void sort_by_ratio();
extern int check_evaluate_and_print_sol(int *sol,  int *total_value, int *total_weight);
void enumerate();
int next_binary(int *str, int Nitems);

int main(int argc, char *argv[])
{
print_instance();
enumerate();
return(0);
}

void enumerate()
{
// Do an exhaustive search (aka enumeration) of all possible ways to pack
// the knapsack.
// This is achieved by creating every binary solution vector of length Nitems.
// For each solution vector, its value and weight is calculated.

int i;  // item index
int solution[Nitems+1];   // (binary) solution vector representing items packed
int best_solution[Nitems+1];  // (binary) solution vector for best solution found
int best_value; // total value packed in the best solution
double j=0;
int total_value, total_weight; // total value and total weight of current knapsack solution
int infeasible;  // 0 means feasible; -1 means infeasible (violates the capacity constraint)

// set the knapsack initially empty
for(i=1;i<=Nitems;i++)
{
solution[i]=0;
}
QUIET=1;
best_value=0;

while(!(next_binary(&solution[1], Nitems)))
{

/* ADD CODE IN HERE TO KEEP TRACK OF FRACTION OF ENUMERATION DONE */

// calculates the value and weight and feasibility:
infeasible=check_evaluate_and_print_sol(solution, &total_value, &total_weight);
/* ADD CODE IN HERE TO KEEP TRACK OF BEST SOLUTION FOUND*/

}
/* ADD CODE TO PRINT OUT BEST SOLUTION */

}

int next_binary(int *str, int Nitems)
{
// Called with a binary string of length Nitems, this
// function adds "1" to the string, e.g. 0001 would turn to 0010.
// If the string overflows, then the function returns 1, else it returns 0.
int i=Nitems-1;
while(i>=0)
{
if(str[i]==1)
{
str[i]=0;
i--;
}
else
{
str[i]=1;
break;
}
}
if(i==-1)
{
return(1);
}
else
{
return(0);
}
}
``````

A genuine UoM lab.

``````if(computedDate != null){
myObject.setDueDate(computedDate);
}
else{
myObject.setDueDate(null);
}``````
``````/**
* Creates hash of client/customer password
* @return string MD5 hash of password with salt
*/
{
}``````
``````<?
function null(\$null) {
return null;
}``````
``````    \$partnerChargesRegular = \$row['charges'];
\$partnerChargesIrregular = \$row['charges'];
if (!isset(\$partnerChargesIrregular) || \$partnerChargesIrregular == "") {
\$partnerChargesIrregular = \$partnerChargesRegular;
}``````

Look. We take A from X and B from X. Then, you make a check, and if it is true you assing A to B. BUT A AND B ARE TAKEN FROM THE SAME X PLACE!!! HOW CAN THEY DIFFER?!?!!!?!?!?!?!!

``````\$options.splice(\$options.indexOf('option7'), 1);
\$options.splice(\$options.indexOf('option5'), 1);
\$options.splice(\$options.indexOf('option4'), 1);
\$options.splice(\$options.indexOf('option3'), 1);
\$options.splice(\$options.indexOf('option2'), 1);
\$options.splice(\$options.indexOf('option1'), 1);``````
``````	public static int findSplitVariable(LinkedList<ByteDataRow> matrix) {
int maxNoOfZeros = 0;
int maxNoOfOnes = 0;
int varId = -1;
int[] NoOfOnesInColumn = new int[matrix.get(0).getInVars().length];

for (ByteDataRow bdr : matrix) {
int tmpNoOfZeros = bdr.getNumberOfZeros();
if (maxNoOfZeros < tmpNoOfZeros) {
list.clear();
maxNoOfZeros = tmpNoOfZeros;
} else if (maxNoOfZeros == tmpNoOfZeros) {
}
}

for (ByteDataRow bdr : list) {
byte[] vars = bdr.getInVars();
for (int i = 0; i < vars.length; i++) {
NoOfOnesInColumn[i] = NoOfOnesInColumn[i]
+ Byte.compare(vars[i], Byte.parseByte("0"));
if (NoOfOnesInColumn[i] > maxNoOfOnes) {
maxNoOfOnes = NoOfOnesInColumn[i];
varId = i;
}
}
}

return varId;
}

public static int findSplitVariable(LinkedList<ByteDataRow> matrix, int varIdx) {
int maxNoOfZeros = 0;
int maxNoOfOnes = 0;
int varId = -1;
int[] NoOfOnesInColumn = new int[matrix.get(0).getInVars().length];

// Wybierz kostkÍ z najwiÍkszπ liczbπ zer.
for (ByteDataRow bdr : matrix) {
int tmpNoOfZeros = bdr.getNumberOfZeros();
if (maxNoOfZeros < tmpNoOfZeros) {
list.clear();
maxNoOfZeros = tmpNoOfZeros;
} else if (maxNoOfZeros == tmpNoOfZeros) {
}
}

for (ByteDataRow bdr : list) {
byte[] vars = bdr.getInVars();
for (int i = 0; i < vars.length; i++) {
NoOfOnesInColumn[i] = NoOfOnesInColumn[i]
+ Byte.compare(vars[i], Byte.parseByte("0"));
if (NoOfOnesInColumn[i] > maxNoOfOnes) {
maxNoOfOnes = NoOfOnesInColumn[i];
varId = i;
}
}
}

return varId;
}
``````

There are two methods findSplitVariable. Second one takes extra parameter (varIdx) that is not used anywhere.

``````base.transform.name = this.bodyName;
this.mass = Math.Pow(this.radius, 2.0) * this.surfaceGravity;
this.cameraSwitchHeightM = this.cameraSwitchHeightKm * 1000.0;
{
}
this.atmosphereData.atmosphereHeightM = this.atmosphereData.atmosphereHeightKm * 1000.0;
if (this.terrainData.terrainMaterial != null)
{
this.terrainData.terrainMaterial.color = this.terrainData.terrainColor;
}
this.terrainData.maxTerrainHeight = this.GetMaxTerrainHeight();
this.terrainData.unitToAngle = 360.0 / ((this.radius + this.terrainData.maxTerrainHeight) * 2.0 * 3.1415926535897931);
for (int i = 0; i < this.terrainData.detailLevels.Length; i++)
{
this.terrainData.detailLevels[i].chunckSize = (double)this.terrainData.baseChunckSize / Math.Pow(2.0, (double)i);
this.terrainData.detailLevels[i].angularSize = (float)this.terrainData.detailLevels[i].chunckSize / (float)this.terrainData.heightMaps[0].heightMap.HeightDataArray.Length * 360f;
}
if (this.type == CelestialBodyData.Type.Star)
{
this.parentBody = null;
this.orbitData.SOIMultiplier = double.PositiveInfinity;
}
if (this.parentBody != null && (this.type == this.parentBody.type || (this.type == CelestialBodyData.Type.Planet && this.parentBody.type == CelestialBodyData.Type.Moon)))
{
this.parentBody = null;
}
if (this.parentBody != null)
{
this.orbitData._period = Kepler.GetPeriod(0.0, this.orbitData.orbitHeightM, this.parentBody.mass);
this.orbitData.periodString = Ref.GetTimeString(this.orbitData._period);
this.orbitData._meanMotion = -6.2831853071795862 / this.orbitData._period;
this.orbitData.orbitalVelocity = this.orbitData.orbitHeightM * this.orbitData._meanMotion;
this.orbitData.SOI = this.orbitData.orbitHeightM * Math.Pow(this.mass / this.parentBody.mass, 0.4) * this.orbitData.SOIMultiplier;
if (!this.ParentHasThisBodyAsSatellite())
{
List<CelestialBodyData> list = new List<CelestialBodyData>(this.parentBody.satellites);
this.parentBody.satellites = list.ToArray();
this.parentBody.ValidateSatellites();
}``````
``````
\$d = explode(".",\$request->get("due_date",".."));
foreach (\$d as \$key => \$val) \$d[\$key]=(int)\$val;

if (
!is_numeric(\$d[0]) || \$d[0]<1 ||\$d[0]>31 ||
!is_numeric(\$d[1]) || \$d[1]<1 ||\$d[1]>12 ||
!is_numeric(\$d[2]) || \$d[2]<2005 ||\$d[2]>2100 ) {
\$error["due_date"] = "Missing date.";
}``````

I think this was the last piece of code the developer wrote .... :D

``````<?php
\$k =1;
for(\$v = 0; \$v < \$nt; \$v++) {
\$bgClass= 'blueBg';
if(\$k > 1 && \$k%2 == 0){
\$bgClass= 'whiteBg';
}
?>
<tr  class="row_tr <?php echo \$bgClass;?>">
<td class="row_td td_column_0">&nbsp;</td>
<td class="row_td column_1"><?php echo \$rows[\$v]['nothing'];?></td>
...
<td class="row_td td_column_0">&nbsp;</td>
</tr>

<?php
\$k++;
}
?>
``````
``````var filter = options.dataSource.filter();

if(e.filter) {
filter = filter && filter.filters.length ? filter.filters.concat(e.filter.filter) : e.filter.filters;
}
else {
filter = filter && filter.filters.length ? filter.filters.linqRemove({ field: e.field }) : [];
}
options.dataSource.filter(filter);``````
``````...
if (alignEntrySize & 1)
alignEntrySize++;
if (alignEntrySize & 2)
alignEntrySize += 2;
...``````