public void putAll(Map<? extends Float, ? extends Byte> map) {
   synchronized (mutex) {
     m.putAll(map);
   }
 }
 public boolean containsKey(float key) {
   synchronized (mutex) {
     return m.containsKey(key);
   }
 }
 public byte get(float key) {
   synchronized (mutex) {
     return m.get(key);
   }
 }
 public int hashCode() {
   synchronized (mutex) {
     return m.hashCode();
   }
 }
 public int size() {
   synchronized (mutex) {
     return m.size();
   }
 }
 public boolean increment(float key) {
   synchronized (mutex) {
     return m.increment(key);
   }
 }
 public byte adjustOrPutValue(float key, byte adjust_amount, byte put_amount) {
   synchronized (mutex) {
     return m.adjustOrPutValue(key, adjust_amount, put_amount);
   }
 }
 public TByteCollection valueCollection() {
   synchronized (mutex) {
     if (values == null) values = new TSynchronizedByteCollection(m.valueCollection(), mutex);
     return values;
   }
 }
 public byte[] values() {
   synchronized (mutex) {
     return m.values();
   }
 }
 public float[] keys() {
   synchronized (mutex) {
     return m.keys();
   }
 }
 public float[] keys(float[] array) {
   synchronized (mutex) {
     return m.keys(array);
   }
 }
 public TFloatSet keySet() {
   synchronized (mutex) {
     if (keySet == null) keySet = new TSynchronizedFloatSet(m.keySet(), mutex);
     return keySet;
   }
 }
 public void clear() {
   synchronized (mutex) {
     m.clear();
   }
 }
 public void putAll(TFloatByteMap map) {
   synchronized (mutex) {
     m.putAll(map);
   }
 }
 public void transformValues(TByteFunction function) {
   synchronized (mutex) {
     m.transformValues(function);
   }
 }
 public byte[] values(byte[] array) {
   synchronized (mutex) {
     return m.values(array);
   }
 }
 public boolean retainEntries(TFloatByteProcedure procedure) {
   synchronized (mutex) {
     return m.retainEntries(procedure);
   }
 }
 public TFloatByteIterator iterator() {
   return m.iterator(); // Must be manually synched by user!
 }
 public boolean adjustValue(float key, byte amount) {
   synchronized (mutex) {
     return m.adjustValue(key, amount);
   }
 }
 // these are unchanging over the life of the map, no need to lock
 public float getNoEntryKey() {
   return m.getNoEntryKey();
 }
 public boolean equals(Object o) {
   synchronized (mutex) {
     return m.equals(o);
   }
 }
 public byte getNoEntryValue() {
   return m.getNoEntryValue();
 }
 public String toString() {
   synchronized (mutex) {
     return m.toString();
   }
 }
 public boolean forEachKey(TFloatProcedure procedure) {
   synchronized (mutex) {
     return m.forEachKey(procedure);
   }
 }
 public boolean isEmpty() {
   synchronized (mutex) {
     return m.isEmpty();
   }
 }
 public boolean forEachValue(TByteProcedure procedure) {
   synchronized (mutex) {
     return m.forEachValue(procedure);
   }
 }
 public boolean containsValue(byte value) {
   synchronized (mutex) {
     return m.containsValue(value);
   }
 }
 public boolean forEachEntry(TFloatByteProcedure procedure) {
   synchronized (mutex) {
     return m.forEachEntry(procedure);
   }
 }
 public byte put(float key, byte value) {
   synchronized (mutex) {
     return m.put(key, value);
   }
 }
 public byte remove(float key) {
   synchronized (mutex) {
     return m.remove(key);
   }
 }