------------------------------------------------------- Mip map -------------------------------------------------------
491666
function MipMap () {
    TexFlags.call(this)

    this.genMipmaps = false
    this.mipmapHint = GL_DONT_CARE
    this.mipmask = 0
    this.images = Array(16)
  }
156549
public static void writeMapFile (BufferedWriter bout, HashMap<String, Integer> map)
        throws IOException
    {
        String[] lines = new String[map.size()];
        Iterator<String> iter = map.keySet().iterator();
        for (int ii = 0; iter.hasNext(); ii++) {
            String key = iter.next();
            Integer value = map.get(key);
            lines[ii] = key + SEP_STR + value;
        }
        QuickSort.sort(lines);
        for (String line : lines) {
            bout.write(line, 0, line.length());
            bout.newLine();
        }
        bout.flush();
    }
1296716
Map<Integer, List<Integer>> initTreeMap() {
        Map<Integer, List<Integer>> treeMap = new LinkedHashMap<>(numWorkers);
        for(int r = 0; r < numWorkers; r++) {
            treeMap.put(r, getNeighbours(r));
        }
        return treeMap;
    }
446645
private void populateMap(byte[] data, Integer previousItemOffset, Integer previousItemKey, Integer itemOffset)
   {
      if (previousItemOffset != null)
      {
         int itemSize = itemOffset.intValue() - previousItemOffset.intValue();
         byte[] itemData = new byte[itemSize];
         System.arraycopy(data, previousItemOffset.intValue(), itemData, 0, itemSize);
         m_map.put(previousItemKey, itemData);
      }
   }
349133
private void createDefaultMappers() {
    BooleanMapper booleanMapper = new BooleanMapper();
    CharMapper charMapper = new CharMapper();
    ShortMapper shortMapper = new ShortMapper();
    IntegerMapper integerMapper = new IntegerMapper();
    LongMapper longMapper = new LongMapper();
    FloatMapper floatMapper = new FloatMapper();
    DoubleMapper doubleMapper = new DoubleMapper();

    cache.put(boolean.class, booleanMapper);
    cache.put(Boolean.class, booleanMapper);
    cache.put(char.class, charMapper);
    cache.put(Character.class, charMapper);
    cache.put(short.class, shortMapper);
    cache.put(Short.class, shortMapper);
    cache.put(int.class, integerMapper);
    cache.put(Integer.class, integerMapper);
    cache.put(long.class, longMapper);
    cache.put(Long.class, longMapper);
    cache.put(float.class, floatMapper);
    cache.put(Float.class, floatMapper);
    cache.put(double.class, doubleMapper);
    cache.put(Double.class, doubleMapper);
    cache.put(String.class, new StringMapper());
    cache.put(BigDecimal.class, new BigDecimalMapper());
    cache.put(byte[].class, new ByteArrayMapper());
    cache.put(char[].class, new CharArrayMapper());
    cache.put(Date.class, new DateMapper());
    cache.put(Calendar.class, new CalendarMapper());
    cache.put(GeoLocation.class, new GeoLocationMapper());
    cache.put(DatastoreKey.class, new KeyMapper());
    cache.put(LocalDate.class, new LocalDateMapper());
    cache.put(LocalTime.class, new LocalTimeMapper());
    cache.put(LocalDateTime.class, new LocalDateTimeMapper());
    cache.put(OffsetDateTime.class, new OffsetDateTimeMapper());
    cache.put(ZonedDateTime.class, new ZonedDateTimeMapper());
  }
501296
function mapLog(...tags) {
    /**
     * Array logge Prinst every value on separated line
     * @function printArray
     * @param {Array} message Printed list
     * @returns {Array}
     */
    function printArray(message) {
      if (active) {
        arrayCheck(message)
        const tag = normalizeDefaults(tags)
        //count length + 2. Also handles edge case with objects without 'length' field
        const spaceLn = P(
          length,
          defaultTo(0),
          add(2) )
        const ln = sum( map( spaceLn, tags ) )
        const spaces = new Array(ln)
          .fill(' ')
          .join('')

        const getFormatted = num => chalk.green(`<${num}>`)
        levelLogger( tag, getFormatted(0), head( message ) )
        const printTail = (e, i) => levelLogger(spaces, getFormatted(i+1), e)

        P(
          tail,
          indexedMap(printTail)
        )(message)
      }
      return message
    }
    return printArray
  }
1225799
@Override
	public final void map(INPUT_KEY key, INPUT_VALUE value, Context context)
	    throws IOException, InterruptedException {
		map(key, value, this.context, collector);
	}
1332483
public Map<Integer, String> asMap() {
		initializePosition();
		final Map<Integer, String> results = Maps.newHashMap();
		
		Mapper.from(positions.get()).entryLoop(new Decisional<Map.Entry<Integer, Pair<Integer,Integer>>>() {

			@Override protected void decision(Entry<Integer, Pair<Integer, Integer>> input) {
				results.put(input.getKey(), doSubstring(input.getValue()));
			}
		});
		
		return results;
	}
365419
@Override
    public Object map(Object input) {
        List<Long> list = (List<Long>) input;
        switch (mathOp) {
            case Add:
                long sum = 0;
                for (Long w : list)
                    sum += w;
                return new LongWritable(sum);
            case Subtract:
                return list.get(0) - list.get(1);
            case Multiply:
                long product = 1;
                for (Long w : list)
                    product *= w;
                return product;
            case Divide:
                return list.get(0) / list.get(1);
            case Modulus:
                return list.get(0) % list.get(1);
            case ReverseSubtract:
            case ReverseDivide:
            case ScalarMin:
            case ScalarMax:
            default:
                throw new RuntimeException("Invalid mathOp: " + mathOp); //Should never happen
        }
    }
638589
public void putMap (Map<String,String> map) {                                                       //SIB0163.comms.1
     if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putMap", "map="+map);

     if (map != null) {
       final Set<String> keys = map.keySet();
       putShort(keys.size()); // Number of entries
       for (String k: keys) {
         putString(k);
         putString(map.get(k));
       }
     } else {
       putShort(0);
     }

     if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putMap");
   }
28717
private static void initMap() {
    // Go through all the enum constants and build a map of
    // LayoutVersion <-> EnumSet of all supported features in that LayoutVersion
    for (Feature f : Feature.values()) {
      EnumSet<Feature> ancestorSet = map.get(f.ancestorLV);
      if (ancestorSet == null) {
        ancestorSet = EnumSet.noneOf(Feature.class); // Empty enum set
        map.put(f.ancestorLV, ancestorSet);
      }
      EnumSet<Feature> featureSet = EnumSet.copyOf(ancestorSet);
      featureSet.add(f);
      map.put(f.lv, featureSet);
    }
    
    // Special initialization for 0.20.203 and 0.20.204
    // to add Feature#DELEGATION_TOKEN
    specialInit(Feature.RESERVED_REL20_203.lv, Feature.DELEGATION_TOKEN);
    specialInit(Feature.RESERVED_REL20_204.lv, Feature.DELEGATION_TOKEN);
  }
126455
public void map(K key, V val,
                  OutputCollector<Text, Text> output, Reporter reporter) throws IOException {
    String valStr = val.toString();
    String[] inputValFields = valStr.split(this.fieldSeparator);
    String[] inputKeyFields = null;
    String[] fields = null;
    if (this.ignoreInputKey) {
      fields = inputValFields;
    } else {
      inputKeyFields = key.toString().split(this.fieldSeparator);
      fields = new String[inputKeyFields.length + inputValFields.length];
      int i = 0;
      for (i = 0; i < inputKeyFields.length; i++) {
        fields[i] = inputKeyFields[i];
      }
      for (i = 0; i < inputValFields.length; i++) {
        fields[inputKeyFields.length + i] = inputValFields[i];
      }
    }
    String newKey = selectFields(fields, mapOutputKeyFieldList, -1,
        fieldSeparator);
    String newVal = selectFields(fields, mapOutputValueFieldList,
        allMapValueFieldsFrom, fieldSeparator);

    if (newKey == null) {
      newKey = newVal;
      newVal = null;
    }
    Text newTextKey = emptyText;
    if (newKey != null) {
      newTextKey = new Text(newKey);
    }
    Text newTextVal = emptyText;
    if (newTextVal != null) {
      newTextVal = new Text(newVal);
    }
    output.collect(newTextKey, newTextVal);
  }
541663
void buildMapEntry(LinkedHashMap<Object, Expr> map) {
		Expr keyExpr = expr();
		Object key;
		if (keyExpr instanceof Id) {
			key = ((Id)keyExpr).getId();
		} else if (keyExpr instanceof Const) {
			key = ((Const)keyExpr).getValue();
		} else {
			throw new ParseException("Expression error: the value of map key must be identifier, String, Boolean, null or Number", location);
		}
		
		match(Sym.COLON);
		Expr value = expr();
		if (value == null) {
			throw new ParseException("Expression error: the value on the right side of map entry can not be blank", location);
		}
		map.put(key, value);
	}
1280715
private static void writeStringMap(SymbolTable map, ObjectOutput out)
      throws IOException {
    out.writeInt(map.size());
    for (ObjectIntCursor<String> cursor : map) {
      out.writeUTF(cursor.key);
      out.writeInt(cursor.value);
    }
  }
1201714
void printMap(PrintWriter out, Map<String, Map<String, List<TagsMetricsPair>>> map) {
    for (Map.Entry<String, Map<String, List<TagsMetricsPair>>> context : map.entrySet()) {
      out.println(context.getKey());
      for (Map.Entry<String, List<TagsMetricsPair>> record : context.getValue().entrySet()) {
        indent(out, 1);
        out.println(record.getKey());
        for (TagsMetricsPair pair : record.getValue()) {
          indent(out, 2);
          // Prints tag values in the form "{key=value,key=value}:"
          out.print("{");
          boolean first = true;
          for (Map.Entry<String, Object> tagValue : pair.tagMap.entrySet()) {
            if (first) {
              first = false;
            } else {
              out.print(",");
            }
            out.print(tagValue.getKey());
            out.print("=");
            out.print(tagValue.getValue().toString());
          }
          out.println("}:");
          
          // Now print metric values, one per line
          for (Map.Entry<String, Number> metricValue : 
              pair.metricMap.entrySet()) {
            indent(out, 3);
            out.print(metricValue.getKey());
            out.print("=");
            out.println(metricValue.getValue().toString());
          }
        }
      }
    }    
  }
1082774
function step2 ( map ) {
				var root = { name : "/", nodes : []};
				return ( function next ( map, parent, level ) {
					gui.Object.each ( map, function ( key, val ) {
						var node = { name : key };
						if ( typeof ( val ) === "object" ) {
							node.nodes = [];
							node.open = level < 1;
							next ( val, node, level + 1 );
						} else {
							node.src = val;
						}
						parent.nodes.push ( node );
					});
					return parent;
				}) ( map, root, 0 );
			}
1103921
function(input,key,size)
		{
			var output = [];
			var block = []; /* the 128 bit block to encode */
			var nbrRounds = this.numberOfRounds(size);
			/* Set the block values, for the block:
			 * a0,0 a0,1 a0,2 a0,3
			 * a1,0 a1,1 a1,2 a1,3
			 * a2,0 a2,1 a2,2 a2,3
			 * a3,0 a3,1 a3,2 a3,3
			 * the mapping order is a0,0 a1,0 a2,0 a3,0 a0,1 a1,1 ... a2,3 a3,3
			 */
			for (var i = 0; i < 4; i++) /* iterate over the columns */
				for (var j = 0; j < 4; j++) /* iterate over the rows */
					block[(i+(j*4))] = input[(i*4)+j];
		
			/* expand the key into an 176, 208, 240 bytes key */
			var expandedKey = this.expandKey(key, size); /* the expanded key */
			/* encrypt the block using the expandedKey */
			block = this.main(block, expandedKey, nbrRounds);
			for (var k = 0; k < 4; k++) /* unmap the block again into the output */
				for (var l = 0; l < 4; l++) /* iterate over the rows */
					output[(k*4)+l] = block[(k+(l*4))];
			return output;
		}