public final class io.micronaut.core.util.clhm.ConcurrentLinkedHashMap<K, V> extends java.util.AbstractMap<K, V> implements java.util.concurrent.ConcurrentMap<K, V>, java.io.Serializable
  minor version: 0
  major version: 59
  flags: flags: (0x0031) ACC_PUBLIC, ACC_FINAL, ACC_SUPER
  this_class: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  super_class: java.util.AbstractMap
{
  static final int NCPU;
    descriptor: I
    flags: (0x0018) ACC_STATIC, ACC_FINAL

  static final long MAXIMUM_CAPACITY;
    descriptor: J
    flags: (0x0018) ACC_STATIC, ACC_FINAL
    ConstantValue: 9223372034707292160

  static final int NUMBER_OF_READ_BUFFERS;
    descriptor: I
    flags: (0x0018) ACC_STATIC, ACC_FINAL

  static final int READ_BUFFERS_MASK;
    descriptor: I
    flags: (0x0018) ACC_STATIC, ACC_FINAL

  static final int READ_BUFFER_THRESHOLD;
    descriptor: I
    flags: (0x0018) ACC_STATIC, ACC_FINAL
    ConstantValue: 32

  static final int READ_BUFFER_DRAIN_THRESHOLD;
    descriptor: I
    flags: (0x0018) ACC_STATIC, ACC_FINAL
    ConstantValue: 64

  static final int READ_BUFFER_SIZE;
    descriptor: I
    flags: (0x0018) ACC_STATIC, ACC_FINAL
    ConstantValue: 128

  static final int READ_BUFFER_INDEX_MASK;
    descriptor: I
    flags: (0x0018) ACC_STATIC, ACC_FINAL
    ConstantValue: 127

  static final int WRITE_BUFFER_DRAIN_THRESHOLD;
    descriptor: I
    flags: (0x0018) ACC_STATIC, ACC_FINAL
    ConstantValue: 16

  static final java.util.Queue<?> DISCARDING_QUEUE;
    descriptor: Ljava/util/Queue;
    flags: (0x0018) ACC_STATIC, ACC_FINAL
    Signature: Ljava/util/Queue<*>;

  private static final long serialVersionUID;
    descriptor: J
    flags: (0x001a) ACC_PRIVATE, ACC_STATIC, ACC_FINAL
    ConstantValue: 1

  private final java.util.concurrent.ConcurrentMap<K, io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node<K, V>> data;
    descriptor: Ljava/util/concurrent/ConcurrentMap;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL
    Signature: Ljava/util/concurrent/ConcurrentMap<TK;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;>;

  private final int concurrencyLevel;
    descriptor: I
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL

  private final long[] readBufferReadCount;
    descriptor: [J
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")

  private final io.micronaut.core.util.clhm.LinkedDeque<io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node<K, V>> evictionDeque;
    descriptor: Lio/micronaut/core/util/clhm/LinkedDeque;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL
    Signature: Lio/micronaut/core/util/clhm/LinkedDeque<Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;>;
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")

  private final java.util.concurrent.atomic.AtomicLong weightedSize;
    descriptor: Ljava/util/concurrent/atomic/AtomicLong;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")

  private final java.util.concurrent.atomic.AtomicLong capacity;
    descriptor: Ljava/util/concurrent/atomic/AtomicLong;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")

  private final java.util.concurrent.locks.Lock evictionLock;
    descriptor: Ljava/util/concurrent/locks/Lock;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL

  private final java.util.Queue<java.lang.Runnable> writeBuffer;
    descriptor: Ljava/util/Queue;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL
    Signature: Ljava/util/Queue<Ljava/lang/Runnable;>;

  private final java.util.concurrent.atomic.AtomicLong[] readBufferWriteCount;
    descriptor: [Ljava/util/concurrent/atomic/AtomicLong;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL

  private final java.util.concurrent.atomic.AtomicLong[] readBufferDrainAtWriteCount;
    descriptor: [Ljava/util/concurrent/atomic/AtomicLong;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL

  private final java.util.concurrent.atomic.AtomicReference<io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node<K, V>>[][] readBuffers;
    descriptor: [[Ljava/util/concurrent/atomic/AtomicReference;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL
    Signature: [[Ljava/util/concurrent/atomic/AtomicReference<Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;>;

  private final java.util.concurrent.atomic.AtomicReference<io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus> drainStatus;
    descriptor: Ljava/util/concurrent/atomic/AtomicReference;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL
    Signature: Ljava/util/concurrent/atomic/AtomicReference<Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$DrainStatus;>;

  private final io.micronaut.core.util.clhm.EntryWeigher<? super K, ? super V> weigher;
    descriptor: Lio/micronaut/core/util/clhm/EntryWeigher;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL
    Signature: Lio/micronaut/core/util/clhm/EntryWeigher<-TK;-TV;>;

  private final java.util.Queue<io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node<K, V>> pendingNotifications;
    descriptor: Ljava/util/Queue;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL
    Signature: Ljava/util/Queue<Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;>;

  private final io.micronaut.core.util.clhm.EvictionListener<K, V> listener;
    descriptor: Lio/micronaut/core/util/clhm/EvictionListener;
    flags: (0x0012) ACC_PRIVATE, ACC_FINAL
    Signature: Lio/micronaut/core/util/clhm/EvictionListener<TK;TV;>;

  private transient java.util.Set<K> keySet;
    descriptor: Ljava/util/Set;
    flags: (0x0082) ACC_PRIVATE, ACC_TRANSIENT
    Signature: Ljava/util/Set<TK;>;

  private transient java.util.Collection<V> values;
    descriptor: Ljava/util/Collection;
    flags: (0x0082) ACC_PRIVATE, ACC_TRANSIENT
    Signature: Ljava/util/Collection<TV;>;

  private transient java.util.Set<java.util.Map$Entry<K, V>> entrySet;
    descriptor: Ljava/util/Set;
    flags: (0x0082) ACC_PRIVATE, ACC_TRANSIENT
    Signature: Ljava/util/Set<Ljava/util/Map$Entry<TK;TV;>;>;

  static void <clinit>();
    descriptor: ()V
    flags: (0x0008) ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: .line 148
            invokestatic java.lang.Runtime.getRuntime:()Ljava/lang/Runtime;
            invokevirtual java.lang.Runtime.availableProcessors:()I
            putstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.NCPU:I
         1: .line 154
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.NCPU:I
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.ceilingNextPowerOfTwo:(I)I
            putstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.NUMBER_OF_READ_BUFFERS:I
         2: .line 157
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.NUMBER_OF_READ_BUFFERS:I
            iconst_1
            isub
            putstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.READ_BUFFERS_MASK:I
         3: .line 175
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DiscardingQueue
            dup
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DiscardingQueue.<init>:()V
            putstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.DISCARDING_QUEUE:Ljava/util/Queue;
         4: .line 177
            return
      LocalVariableTable:
        Start  End  Slot  Name  Signature

  private void <init>(io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder<K, V>);
    descriptor: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Builder;)V
    flags: (0x0002) ACC_PRIVATE
    Code:
      stack=7, locals=4, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder builder
         0: .line 215
            aload 0 /* this */
            invokespecial java.util.AbstractMap.<init>:()V
         1: .line 217
            aload 0 /* this */
            aload 1 /* builder */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder.concurrencyLevel:I
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.concurrencyLevel:I
         2: .line 218
            aload 0 /* this */
            new java.util.concurrent.atomic.AtomicLong
            dup
            aload 1 /* builder */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder.capacity:J
            ldc 9223372034707292160
            invokestatic java.lang.Math.min:(JJ)J
            invokespecial java.util.concurrent.atomic.AtomicLong.<init>:(J)V
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.capacity:Ljava/util/concurrent/atomic/AtomicLong;
         3: .line 219
            aload 0 /* this */
            new java.util.concurrent.ConcurrentHashMap
            dup
            aload 1 /* builder */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder.initialCapacity:I
            ldc 0.75
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.concurrencyLevel:I
            invokespecial java.util.concurrent.ConcurrentHashMap.<init>:(IFI)V
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
         4: .line 222
            aload 0 /* this */
            aload 1 /* builder */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder.weigher:Lio/micronaut/core/util/clhm/EntryWeigher;
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weigher:Lio/micronaut/core/util/clhm/EntryWeigher;
         5: .line 223
            aload 0 /* this */
            new java.util.concurrent.locks.ReentrantLock
            dup
            invokespecial java.util.concurrent.locks.ReentrantLock.<init>:()V
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
         6: .line 224
            aload 0 /* this */
            new java.util.concurrent.atomic.AtomicLong
            dup
            invokespecial java.util.concurrent.atomic.AtomicLong.<init>:()V
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weightedSize:Ljava/util/concurrent/atomic/AtomicLong;
         7: .line 225
            aload 0 /* this */
            new io.micronaut.core.util.clhm.LinkedDeque
            dup
            invokespecial io.micronaut.core.util.clhm.LinkedDeque.<init>:()V
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionDeque:Lio/micronaut/core/util/clhm/LinkedDeque;
         8: .line 226
            aload 0 /* this */
            new java.util.concurrent.ConcurrentLinkedQueue
            dup
            invokespecial java.util.concurrent.ConcurrentLinkedQueue.<init>:()V
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.writeBuffer:Ljava/util/Queue;
         9: .line 227
            aload 0 /* this */
            new java.util.concurrent.atomic.AtomicReference
            dup
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus.IDLE:Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$DrainStatus;
            invokespecial java.util.concurrent.atomic.AtomicReference.<init>:(Ljava/lang/Object;)V
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainStatus:Ljava/util/concurrent/atomic/AtomicReference;
        10: .line 229
            aload 0 /* this */
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.NUMBER_OF_READ_BUFFERS:I
            newarray 11
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferReadCount:[J
        11: .line 230
            aload 0 /* this */
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.NUMBER_OF_READ_BUFFERS:I
            anewarray java.util.concurrent.atomic.AtomicLong
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferWriteCount:[Ljava/util/concurrent/atomic/AtomicLong;
        12: .line 231
            aload 0 /* this */
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.NUMBER_OF_READ_BUFFERS:I
            anewarray java.util.concurrent.atomic.AtomicLong
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferDrainAtWriteCount:[Ljava/util/concurrent/atomic/AtomicLong;
        13: .line 232
            aload 0 /* this */
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.NUMBER_OF_READ_BUFFERS:I
            sipush 128
            multianewarray [[Ljava/util/concurrent/atomic/AtomicReference; 2
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBuffers:[[Ljava/util/concurrent/atomic/AtomicReference;
        14: .line 233
            iconst_0
            istore 2 /* i */
        start local 2 // int i
        15: goto 25
        16: .line 234
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder int
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferWriteCount:[Ljava/util/concurrent/atomic/AtomicLong;
            iload 2 /* i */
            new java.util.concurrent.atomic.AtomicLong
            dup
            invokespecial java.util.concurrent.atomic.AtomicLong.<init>:()V
            aastore
        17: .line 235
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferDrainAtWriteCount:[Ljava/util/concurrent/atomic/AtomicLong;
            iload 2 /* i */
            new java.util.concurrent.atomic.AtomicLong
            dup
            invokespecial java.util.concurrent.atomic.AtomicLong.<init>:()V
            aastore
        18: .line 236
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBuffers:[[Ljava/util/concurrent/atomic/AtomicReference;
            iload 2 /* i */
            sipush 128
            anewarray java.util.concurrent.atomic.AtomicReference
            aastore
        19: .line 237
            iconst_0
            istore 3 /* j */
        start local 3 // int j
        20: goto 23
        21: .line 238
      StackMap locals: int
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBuffers:[[Ljava/util/concurrent/atomic/AtomicReference;
            iload 2 /* i */
            aaload
            iload 3 /* j */
            new java.util.concurrent.atomic.AtomicReference
            dup
            invokespecial java.util.concurrent.atomic.AtomicReference.<init>:()V
            aastore
        22: .line 237
            iinc 3 /* j */ 1
      StackMap locals:
      StackMap stack:
        23: iload 3 /* j */
            sipush 128
            if_icmplt 21
        end local 3 // int j
        24: .line 233
            iinc 2 /* i */ 1
      StackMap locals:
      StackMap stack:
        25: iload 2 /* i */
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.NUMBER_OF_READ_BUFFERS:I
            if_icmplt 16
        end local 2 // int i
        26: .line 243
            aload 0 /* this */
            aload 1 /* builder */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder.listener:Lio/micronaut/core/util/clhm/EvictionListener;
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.listener:Lio/micronaut/core/util/clhm/EvictionListener;
        27: .line 244
            aload 0 /* this */
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.listener:Lio/micronaut/core/util/clhm/EvictionListener;
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DiscardingListener.INSTANCE:Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$DiscardingListener;
            if_acmpne 29
        28: .line 245
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.DISCARDING_QUEUE:Ljava/util/Queue;
            goto 30
        29: .line 246
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder
      StackMap stack: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
            new java.util.concurrent.ConcurrentLinkedQueue
            dup
            invokespecial java.util.concurrent.ConcurrentLinkedQueue.<init>:()V
        30: .line 244
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder
      StackMap stack: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap java.util.Queue
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.pendingNotifications:Ljava/util/Queue;
        31: .line 247
            return
        end local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder builder
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot     Name  Signature
            0   32     0     this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0   32     1  builder  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Builder<TK;TV;>;
           15   26     2        i  I
           20   24     3        j  I
    Signature: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Builder<TK;TV;>;)V
    MethodParameters:
         Name  Flags
      builder  

  private static void checkNotNull(java.lang.Object);
    descriptor: (Ljava/lang/Object;)V
    flags: (0x000a) ACC_PRIVATE, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
        start local 0 // java.lang.Object o
         0: .line 250
            aload 0 /* o */
            ifnonnull 2
         1: .line 251
            new java.lang.NullPointerException
            dup
            invokespecial java.lang.NullPointerException.<init>:()V
            athrow
         2: .line 253
      StackMap locals:
      StackMap stack:
            return
        end local 0 // java.lang.Object o
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    3     0     o  Ljava/lang/Object;
    MethodParameters:
      Name  Flags
      o     

  private static int ceilingNextPowerOfTwo(int);
    descriptor: (I)I
    flags: (0x000a) ACC_PRIVATE, ACC_STATIC
    Code:
      stack=4, locals=1, args_size=1
        start local 0 // int x
         0: .line 257
            iconst_1
            bipush 32
            iload 0 /* x */
            iconst_1
            isub
            invokestatic java.lang.Integer.numberOfLeadingZeros:(I)I
            isub
            ishl
            ireturn
        end local 0 // int x
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    1     0     x  I
    MethodParameters:
      Name  Flags
      x     

  private static void checkArgument(boolean);
    descriptor: (Z)V
    flags: (0x000a) ACC_PRIVATE, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
        start local 0 // boolean expression
         0: .line 261
            iload 0 /* expression */
            ifne 2
         1: .line 262
            new java.lang.IllegalArgumentException
            dup
            invokespecial java.lang.IllegalArgumentException.<init>:()V
            athrow
         2: .line 264
      StackMap locals:
      StackMap stack:
            return
        end local 0 // boolean expression
      LocalVariableTable:
        Start  End  Slot        Name  Signature
            0    3     0  expression  Z
    MethodParameters:
            Name  Flags
      expression  

  private static void checkState(boolean);
    descriptor: (Z)V
    flags: (0x000a) ACC_PRIVATE, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
        start local 0 // boolean expression
         0: .line 267
            iload 0 /* expression */
            ifne 2
         1: .line 268
            new java.lang.IllegalStateException
            dup
            invokespecial java.lang.IllegalStateException.<init>:()V
            athrow
         2: .line 270
      StackMap locals:
      StackMap stack:
            return
        end local 0 // boolean expression
      LocalVariableTable:
        Start  End  Slot        Name  Signature
            0    3     0  expression  Z
    MethodParameters:
            Name  Flags
      expression  

  public long capacity();
    descriptor: ()J
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 280
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.capacity:Ljava/util/concurrent/atomic/AtomicLong;
            invokevirtual java.util.concurrent.atomic.AtomicLong.get:()J
            lreturn
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    1     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;

  public void setCapacity(long);
    descriptor: (J)V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=5, locals=4, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // long capacity
         0: .line 291
            lload 1 /* capacity */
            lconst_0
            lcmp
            iflt 1
            iconst_1
            goto 2
      StackMap locals:
      StackMap stack:
         1: iconst_0
      StackMap locals:
      StackMap stack: int
         2: invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkArgument:(Z)V
         3: .line 292
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.lock:()V
         4: .line 294
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.capacity:Ljava/util/concurrent/atomic/AtomicLong;
            lload 1 /* capacity */
            ldc 9223372034707292160
            invokestatic java.lang.Math.min:(JJ)J
            invokevirtual java.util.concurrent.atomic.AtomicLong.lazySet:(J)V
         5: .line 295
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainBuffers:()V
         6: .line 296
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evict:()V
         7: .line 297
            goto 11
      StackMap locals:
      StackMap stack: java.lang.Throwable
         8: astore 3
         9: .line 298
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.unlock:()V
        10: .line 299
            aload 3
            athrow
        11: .line 298
      StackMap locals:
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.unlock:()V
        12: .line 300
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.notifyListener:()V
        13: .line 301
            return
        end local 1 // long capacity
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot      Name  Signature
            0   14     0      this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0   14     1  capacity  J
      Exception table:
        from    to  target  type
           4     8       8  any
    MethodParameters:
          Name  Flags
      capacity  

  private boolean hasOverflowed();
    descriptor: ()Z
    flags: (0x0002) ACC_PRIVATE
    Code:
      stack=4, locals=1, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 305
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weightedSize:Ljava/util/concurrent/atomic/AtomicLong;
            invokevirtual java.util.concurrent.atomic.AtomicLong.get:()J
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.capacity:Ljava/util/concurrent/atomic/AtomicLong;
            invokevirtual java.util.concurrent.atomic.AtomicLong.get:()J
            lcmp
            ifle 1
            iconst_1
            ireturn
      StackMap locals:
      StackMap stack:
         1: iconst_0
            ireturn
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    2     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")

  private void evict();
    descriptor: ()V
    flags: (0x0002) ACC_PRIVATE
    Code:
      stack=3, locals=2, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 316
            goto 7
         1: .line 317
      StackMap locals:
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionDeque:Lio/micronaut/core/util/clhm/LinkedDeque;
            invokevirtual io.micronaut.core.util.clhm.LinkedDeque.poll:()Lio/micronaut/core/util/clhm/Linked;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 1 /* node */
        start local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         2: .line 321
            aload 1 /* node */
            ifnonnull 4
         3: .line 322
            return
         4: .line 326
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 1 /* node */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.key:Ljava/lang/Object;
            aload 1 /* node */
            invokeinterface java.util.concurrent.ConcurrentMap.remove:(Ljava/lang/Object;Ljava/lang/Object;)Z
            ifeq 6
         5: .line 327
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.pendingNotifications:Ljava/util/Queue;
            aload 1 /* node */
            invokeinterface java.util.Queue.add:(Ljava/lang/Object;)Z
            pop
         6: .line 330
      StackMap locals:
      StackMap stack:
            aload 0 /* this */
            aload 1 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.makeDead:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
        end local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         7: .line 316
      StackMap locals:
      StackMap stack:
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.hasOverflowed:()Z
            ifne 1
         8: .line 332
            return
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    9     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            2    7     1  node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")

  void afterRead(io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node<K, V>);
    descriptor: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
    flags: (0x0000) 
    Code:
      stack=4, locals=5, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         0: .line 340
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferIndex:()I
            istore 2 /* bufferIndex */
        start local 2 // int bufferIndex
         1: .line 341
            aload 0 /* this */
            iload 2 /* bufferIndex */
            aload 1 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.recordRead:(ILio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)J
            lstore 3 /* writeCount */
        start local 3 // long writeCount
         2: .line 342
            aload 0 /* this */
            iload 2 /* bufferIndex */
            lload 3 /* writeCount */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainOnReadIfNeeded:(IJ)V
         3: .line 343
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.notifyListener:()V
         4: .line 344
            return
        end local 3 // long writeCount
        end local 2 // int bufferIndex
        end local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot         Name  Signature
            0    5     0         this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    5     1         node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            1    5     2  bufferIndex  I
            2    5     3   writeCount  J
    Signature: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;)V
    MethodParameters:
      Name  Flags
      node  

  private static int readBufferIndex();
    descriptor: ()I
    flags: (0x000a) ACC_PRIVATE, ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: .line 350
            invokestatic java.lang.Thread.currentThread:()Ljava/lang/Thread;
            invokevirtual java.lang.Thread.getId:()J
            l2i
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.READ_BUFFERS_MASK:I
            iand
            ireturn
      LocalVariableTable:
        Start  End  Slot  Name  Signature

  long recordRead(int, io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node<K, V>);
    descriptor: (ILio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)J
    flags: (0x0000) 
    Code:
      stack=5, locals=7, args_size=3
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // int bufferIndex
        start local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         0: .line 364
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferWriteCount:[Ljava/util/concurrent/atomic/AtomicLong;
            iload 1 /* bufferIndex */
            aaload
            astore 3 /* counter */
        start local 3 // java.util.concurrent.atomic.AtomicLong counter
         1: .line 365
            aload 3 /* counter */
            invokevirtual java.util.concurrent.atomic.AtomicLong.get:()J
            lstore 4 /* writeCount */
        start local 4 // long writeCount
         2: .line 366
            aload 3 /* counter */
            lload 4 /* writeCount */
            lconst_1
            ladd
            invokevirtual java.util.concurrent.atomic.AtomicLong.lazySet:(J)V
         3: .line 368
            lload 4 /* writeCount */
            ldc 127
            land
            l2i
            istore 6 /* index */
        start local 6 // int index
         4: .line 369
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBuffers:[[Ljava/util/concurrent/atomic/AtomicReference;
            iload 1 /* bufferIndex */
            aaload
            iload 6 /* index */
            aaload
            aload 2 /* node */
            invokevirtual java.util.concurrent.atomic.AtomicReference.lazySet:(Ljava/lang/Object;)V
         5: .line 371
            lload 4 /* writeCount */
            lreturn
        end local 6 // int index
        end local 4 // long writeCount
        end local 3 // java.util.concurrent.atomic.AtomicLong counter
        end local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 1 // int bufferIndex
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot         Name  Signature
            0    6     0         this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    6     1  bufferIndex  I
            0    6     2         node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            1    6     3      counter  Ljava/util/concurrent/atomic/AtomicLong;
            2    6     4   writeCount  J
            4    6     6        index  I
    Signature: (ILio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;)J
    MethodParameters:
             Name  Flags
      bufferIndex  
      node         

  void drainOnReadIfNeeded(int, long);
    descriptor: (IJ)V
    flags: (0x0000) 
    Code:
      stack=4, locals=8, args_size=3
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // int bufferIndex
        start local 2 // long writeCount
         0: .line 382
            lload 2 /* writeCount */
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferDrainAtWriteCount:[Ljava/util/concurrent/atomic/AtomicLong;
            iload 1 /* bufferIndex */
            aaload
            invokevirtual java.util.concurrent.atomic.AtomicLong.get:()J
            lsub
            lstore 4 /* pending */
        start local 4 // long pending
         1: .line 383
            lload 4 /* pending */
            ldc 32
            lcmp
            ifge 2
            iconst_1
            goto 3
      StackMap locals: long
      StackMap stack:
         2: iconst_0
      StackMap locals:
      StackMap stack: int
         3: istore 6 /* delayable */
        start local 6 // boolean delayable
         4: .line 384
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainStatus:Ljava/util/concurrent/atomic/AtomicReference;
            invokevirtual java.util.concurrent.atomic.AtomicReference.get:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus
            astore 7 /* status */
        start local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus status
         5: .line 385
            aload 7 /* status */
            iload 6 /* delayable */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus.shouldDrainBuffers:(Z)Z
            ifeq 7
         6: .line 386
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.tryToDrainBuffers:()V
         7: .line 388
      StackMap locals: int io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus
      StackMap stack:
            return
        end local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus status
        end local 6 // boolean delayable
        end local 4 // long pending
        end local 2 // long writeCount
        end local 1 // int bufferIndex
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot         Name  Signature
            0    8     0         this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    8     1  bufferIndex  I
            0    8     2   writeCount  J
            1    8     4      pending  J
            4    8     6    delayable  Z
            5    8     7       status  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$DrainStatus;
    MethodParameters:
             Name  Flags
      bufferIndex  
      writeCount   

  void afterWrite(java.lang.Runnable);
    descriptor: (Ljava/lang/Runnable;)V
    flags: (0x0000) 
    Code:
      stack=2, locals=2, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Runnable task
         0: .line 396
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.writeBuffer:Ljava/util/Queue;
            aload 1 /* task */
            invokeinterface java.util.Queue.add:(Ljava/lang/Object;)Z
            pop
         1: .line 397
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainStatus:Ljava/util/concurrent/atomic/AtomicReference;
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus.REQUIRED:Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$DrainStatus;
            invokevirtual java.util.concurrent.atomic.AtomicReference.lazySet:(Ljava/lang/Object;)V
         2: .line 398
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.tryToDrainBuffers:()V
         3: .line 399
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.notifyListener:()V
         4: .line 400
            return
        end local 1 // java.lang.Runnable task
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    5     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    5     1  task  Ljava/lang/Runnable;
    MethodParameters:
      Name  Flags
      task  

  void tryToDrainBuffers();
    descriptor: ()V
    flags: (0x0000) 
    Code:
      stack=3, locals=2, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 407
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.tryLock:()Z
            ifeq 10
         1: .line 409
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainStatus:Ljava/util/concurrent/atomic/AtomicReference;
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus.PROCESSING:Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$DrainStatus;
            invokevirtual java.util.concurrent.atomic.AtomicReference.lazySet:(Ljava/lang/Object;)V
         2: .line 410
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainBuffers:()V
         3: .line 411
            goto 8
      StackMap locals:
      StackMap stack: java.lang.Throwable
         4: astore 1
         5: .line 412
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainStatus:Ljava/util/concurrent/atomic/AtomicReference;
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus.PROCESSING:Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$DrainStatus;
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus.IDLE:Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$DrainStatus;
            invokevirtual java.util.concurrent.atomic.AtomicReference.compareAndSet:(Ljava/lang/Object;Ljava/lang/Object;)Z
            pop
         6: .line 413
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.unlock:()V
         7: .line 414
            aload 1
            athrow
         8: .line 412
      StackMap locals:
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainStatus:Ljava/util/concurrent/atomic/AtomicReference;
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus.PROCESSING:Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$DrainStatus;
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus.IDLE:Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$DrainStatus;
            invokevirtual java.util.concurrent.atomic.AtomicReference.compareAndSet:(Ljava/lang/Object;Ljava/lang/Object;)Z
            pop
         9: .line 413
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.unlock:()V
        10: .line 416
      StackMap locals:
      StackMap stack:
            return
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0   11     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
      Exception table:
        from    to  target  type
           1     4       4  any

  void drainBuffers();
    descriptor: ()V
    flags: (0x0000) 
    Code:
      stack=1, locals=1, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 421
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainReadBuffers:()V
         1: .line 422
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainWriteBuffer:()V
         2: .line 423
            return
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    3     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")

  void drainReadBuffers();
    descriptor: ()V
    flags: (0x0000) 
    Code:
      stack=3, locals=4, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 428
            invokestatic java.lang.Thread.currentThread:()Ljava/lang/Thread;
            invokevirtual java.lang.Thread.getId:()J
            l2i
            istore 1 /* start */
        start local 1 // int start
         1: .line 429
            iload 1 /* start */
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.NUMBER_OF_READ_BUFFERS:I
            iadd
            istore 2 /* end */
        start local 2 // int end
         2: .line 430
            iload 1 /* start */
            istore 3 /* i */
        start local 3 // int i
         3: goto 6
         4: .line 431
      StackMap locals: int int int
      StackMap stack:
            aload 0 /* this */
            iload 3 /* i */
            getstatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.READ_BUFFERS_MASK:I
            iand
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainReadBuffer:(I)V
         5: .line 430
            iinc 3 /* i */ 1
      StackMap locals:
      StackMap stack:
         6: iload 3 /* i */
            iload 2 /* end */
            if_icmplt 4
        end local 3 // int i
         7: .line 433
            return
        end local 2 // int end
        end local 1 // int start
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot   Name  Signature
            0    8     0   this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            1    8     1  start  I
            2    8     2    end  I
            3    7     3      i  I
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")

  private void drainReadBuffer(int);
    descriptor: (I)V
    flags: (0x0002) ACC_PRIVATE
    Code:
      stack=6, locals=8, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // int bufferIndex
         0: .line 437
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferWriteCount:[Ljava/util/concurrent/atomic/AtomicLong;
            iload 1 /* bufferIndex */
            aaload
            invokevirtual java.util.concurrent.atomic.AtomicLong.get:()J
            lstore 2 /* writeCount */
        start local 2 // long writeCount
         1: .line 438
            iconst_0
            istore 4 /* i */
        start local 4 // int i
         2: goto 12
         3: .line 439
      StackMap locals: long int
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferReadCount:[J
            iload 1 /* bufferIndex */
            laload
            ldc 127
            land
            l2i
            istore 5 /* index */
        start local 5 // int index
         4: .line 440
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBuffers:[[Ljava/util/concurrent/atomic/AtomicReference;
            iload 1 /* bufferIndex */
            aaload
            iload 5 /* index */
            aaload
            astore 6 /* slot */
        start local 6 // java.util.concurrent.atomic.AtomicReference slot
         5: .line 441
            aload 6 /* slot */
            invokevirtual java.util.concurrent.atomic.AtomicReference.get:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 7 /* node */
        start local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         6: .line 442
            aload 7 /* node */
            ifnonnull 8
         7: .line 443
            goto 13
         8: .line 446
      StackMap locals: int java.util.concurrent.atomic.AtomicReference io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            aload 6 /* slot */
            aconst_null
            invokevirtual java.util.concurrent.atomic.AtomicReference.lazySet:(Ljava/lang/Object;)V
         9: .line 447
            aload 0 /* this */
            aload 7 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.applyRead:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
        10: .line 448
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferReadCount:[J
            iload 1 /* bufferIndex */
            dup2
            laload
            lconst_1
            ladd
            lastore
        end local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 6 // java.util.concurrent.atomic.AtomicReference slot
        end local 5 // int index
        11: .line 438
            iinc 4 /* i */ 1
      StackMap locals:
      StackMap stack:
        12: iload 4 /* i */
            bipush 64
            if_icmplt 3
        end local 4 // int i
        13: .line 450
      StackMap locals:
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBufferDrainAtWriteCount:[Ljava/util/concurrent/atomic/AtomicLong;
            iload 1 /* bufferIndex */
            aaload
            lload 2 /* writeCount */
            invokevirtual java.util.concurrent.atomic.AtomicLong.lazySet:(J)V
        14: .line 451
            return
        end local 2 // long writeCount
        end local 1 // int bufferIndex
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot         Name  Signature
            0   15     0         this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0   15     1  bufferIndex  I
            1   15     2   writeCount  J
            2   13     4            i  I
            4   11     5        index  I
            5   11     6         slot  Ljava/util/concurrent/atomic/AtomicReference<Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;>;
            6   11     7         node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")
    MethodParameters:
             Name  Flags
      bufferIndex  

  private void applyRead(io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node<K, V>);
    descriptor: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
    flags: (0x0002) ACC_PRIVATE
    Code:
      stack=2, locals=2, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         0: .line 459
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionDeque:Lio/micronaut/core/util/clhm/LinkedDeque;
            aload 1 /* node */
            invokevirtual io.micronaut.core.util.clhm.LinkedDeque.contains:(Lio/micronaut/core/util/clhm/Linked;)Z
            ifeq 2
         1: .line 460
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionDeque:Lio/micronaut/core/util/clhm/LinkedDeque;
            aload 1 /* node */
            invokevirtual io.micronaut.core.util.clhm.LinkedDeque.moveToBack:(Lio/micronaut/core/util/clhm/Linked;)V
         2: .line 462
      StackMap locals:
      StackMap stack:
            return
        end local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    3     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    3     1  node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
    Signature: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;)V
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")
    MethodParameters:
      Name  Flags
      node  

  void drainWriteBuffer();
    descriptor: ()V
    flags: (0x0000) 
    Code:
      stack=2, locals=3, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 467
            iconst_0
            istore 1 /* i */
        start local 1 // int i
         1: goto 7
         2: .line 468
      StackMap locals: int
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.writeBuffer:Ljava/util/Queue;
            invokeinterface java.util.Queue.poll:()Ljava/lang/Object;
            checkcast java.lang.Runnable
            astore 2 /* task */
        start local 2 // java.lang.Runnable task
         3: .line 469
            aload 2 /* task */
            ifnonnull 5
         4: .line 470
            goto 8
         5: .line 472
      StackMap locals: java.lang.Runnable
      StackMap stack:
            aload 2 /* task */
            invokeinterface java.lang.Runnable.run:()V
        end local 2 // java.lang.Runnable task
         6: .line 467
            iinc 1 /* i */ 1
      StackMap locals:
      StackMap stack:
         7: iload 1 /* i */
            bipush 16
            if_icmplt 2
        end local 1 // int i
         8: .line 474
      StackMap locals:
      StackMap stack:
            return
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    9     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            1    8     1     i  I
            3    6     2  task  Ljava/lang/Runnable;
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")

  boolean tryToRetire(io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node<K, V>, io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue<V>);
    descriptor: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue;)Z
    flags: (0x0000) 
    Code:
      stack=4, locals=4, args_size=3
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        start local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue expect
         0: .line 485
            aload 2 /* expect */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.isAlive:()Z
            ifeq 3
         1: .line 486
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            dup
            aload 2 /* expect */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.value:Ljava/lang/Object;
            aload 2 /* expect */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.weight:I
            ineg
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.<init>:(Ljava/lang/Object;I)V
            astore 3 /* retired */
        start local 3 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue retired
         2: .line 487
            aload 1 /* node */
            aload 2 /* expect */
            aload 3 /* retired */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.compareAndSet:(Ljava/lang/Object;Ljava/lang/Object;)Z
            ireturn
        end local 3 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue retired
         3: .line 489
      StackMap locals:
      StackMap stack:
            iconst_0
            ireturn
        end local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue expect
        end local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot     Name  Signature
            0    4     0     this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    4     1     node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            0    4     2   expect  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
            2    3     3  retired  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
    Signature: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;)Z
    MethodParameters:
        Name  Flags
      node    
      expect  

  void makeRetired(io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node<K, V>);
    descriptor: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
    flags: (0x0000) 
    Code:
      stack=4, locals=4, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         0: .line 500
      StackMap locals:
      StackMap stack:
            aload 1 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.get:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            astore 2 /* current */
        start local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue current
         1: .line 501
            aload 2 /* current */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.isAlive:()Z
            ifne 3
         2: .line 502
            return
         3: .line 504
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
      StackMap stack:
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            dup
            aload 2 /* current */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.value:Ljava/lang/Object;
            aload 2 /* current */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.weight:I
            ineg
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.<init>:(Ljava/lang/Object;I)V
            astore 3 /* retired */
        start local 3 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue retired
         4: .line 505
            aload 1 /* node */
            aload 2 /* current */
            aload 3 /* retired */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.compareAndSet:(Ljava/lang/Object;Ljava/lang/Object;)Z
            ifeq 0
         5: .line 506
            return
        end local 3 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue retired
        end local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue current
        end local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot     Name  Signature
            0    6     0     this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    6     1     node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            1    6     2  current  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
            4    6     3  retired  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
    Signature: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;)V
    MethodParameters:
      Name  Flags
      node  

  void makeDead(io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node<K, V>);
    descriptor: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
    flags: (0x0000) 
    Code:
      stack=5, locals=4, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         0: .line 520
      StackMap locals:
      StackMap stack:
            aload 1 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.get:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            astore 2 /* current */
        start local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue current
         1: .line 521
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            dup
            aload 2 /* current */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.value:Ljava/lang/Object;
            iconst_0
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.<init>:(Ljava/lang/Object;I)V
            astore 3 /* dead */
        start local 3 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue dead
         2: .line 522
            aload 1 /* node */
            aload 2 /* current */
            aload 3 /* dead */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.compareAndSet:(Ljava/lang/Object;Ljava/lang/Object;)Z
            ifeq 0
         3: .line 523
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weightedSize:Ljava/util/concurrent/atomic/AtomicLong;
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weightedSize:Ljava/util/concurrent/atomic/AtomicLong;
            invokevirtual java.util.concurrent.atomic.AtomicLong.get:()J
            aload 2 /* current */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.weight:I
            invokestatic java.lang.Math.abs:(I)I
            i2l
            lsub
            invokevirtual java.util.concurrent.atomic.AtomicLong.lazySet:(J)V
         4: .line 524
            return
        end local 3 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue dead
        end local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue current
        end local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot     Name  Signature
            0    5     0     this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    5     1     node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            1    5     2  current  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
            2    5     3     dead  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
    Signature: (Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;)V
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.GuardedBy(value = "evictionLock")
    MethodParameters:
      Name  Flags
      node  

  void notifyListener();
    descriptor: ()V
    flags: (0x0000) 
    Code:
      stack=3, locals=2, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 532
            goto 2
        start local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         1: .line 533
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.listener:Lio/micronaut/core/util/clhm/EvictionListener;
            aload 1 /* node */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.key:Ljava/lang/Object;
            aload 1 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.getValue:()Ljava/lang/Object;
            invokeinterface io.micronaut.core.util.clhm.EvictionListener.onEviction:(Ljava/lang/Object;Ljava/lang/Object;)V
        end local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         2: .line 532
      StackMap locals:
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.pendingNotifications:Ljava/util/Queue;
            invokeinterface java.util.Queue.poll:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            dup
            astore 1 /* node */
        start local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         3: ifnonnull 1
         4: .line 535
            return
        end local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    5     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            1    2     1  node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            3    5     1  node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;

  public boolean isEmpty();
    descriptor: ()Z
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 541
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            invokeinterface java.util.concurrent.ConcurrentMap.isEmpty:()Z
            ireturn
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    1     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;

  public int size();
    descriptor: ()I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 546
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            invokeinterface java.util.concurrent.ConcurrentMap.size:()I
            ireturn
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    1     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;

  public long weightedSize();
    descriptor: ()J
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=4, locals=1, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 555
            lconst_0
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weightedSize:Ljava/util/concurrent/atomic/AtomicLong;
            invokevirtual java.util.concurrent.atomic.AtomicLong.get:()J
            invokestatic java.lang.Math.max:(JJ)J
            lreturn
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    1     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;

  public void clear();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=3, locals=11, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 560
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.lock:()V
         1: .line 564
            goto 4
        start local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         2: .line 565
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 1 /* node */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.key:Ljava/lang/Object;
            aload 1 /* node */
            invokeinterface java.util.concurrent.ConcurrentMap.remove:(Ljava/lang/Object;Ljava/lang/Object;)Z
            pop
         3: .line 566
            aload 0 /* this */
            aload 1 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.makeDead:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
        end local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         4: .line 564
      StackMap locals:
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionDeque:Lio/micronaut/core/util/clhm/LinkedDeque;
            invokevirtual io.micronaut.core.util.clhm.LinkedDeque.poll:()Lio/micronaut/core/util/clhm/Linked;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            dup
            astore 1 /* node */
        start local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         5: ifnonnull 2
         6: .line 570
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.readBuffers:[[Ljava/util/concurrent/atomic/AtomicReference;
            dup
            astore 5
            arraylength
            istore 4
            iconst_0
            istore 3
            goto 14
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node top int int java.util.concurrent.atomic.AtomicReference[][]
      StackMap stack:
         7: aload 5
            iload 3
            aaload
            astore 2 /* buffer */
        start local 2 // java.util.concurrent.atomic.AtomicReference[] buffer
         8: .line 571
            aload 2 /* buffer */
            dup
            astore 9
            arraylength
            istore 8
            iconst_0
            istore 7
            goto 12
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node java.util.concurrent.atomic.AtomicReference[] int int java.util.concurrent.atomic.AtomicReference[][] top int int java.util.concurrent.atomic.AtomicReference[]
      StackMap stack:
         9: aload 9
            iload 7
            aaload
            astore 6 /* slot */
        start local 6 // java.util.concurrent.atomic.AtomicReference slot
        10: .line 572
            aload 6 /* slot */
            aconst_null
            invokevirtual java.util.concurrent.atomic.AtomicReference.lazySet:(Ljava/lang/Object;)V
        end local 6 // java.util.concurrent.atomic.AtomicReference slot
        11: .line 571
            iinc 7 1
      StackMap locals:
      StackMap stack:
        12: iload 7
            iload 8
            if_icmplt 9
        end local 2 // java.util.concurrent.atomic.AtomicReference[] buffer
        13: .line 570
            iinc 3 1
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node top int int java.util.concurrent.atomic.AtomicReference[][]
      StackMap stack:
        14: iload 3
            iload 4
            if_icmplt 7
        15: .line 578
            goto 17
        start local 2 // java.lang.Runnable task
        16: .line 579
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node java.lang.Runnable
      StackMap stack:
            aload 2 /* task */
            invokeinterface java.lang.Runnable.run:()V
        end local 2 // java.lang.Runnable task
        17: .line 578
      StackMap locals:
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.writeBuffer:Ljava/util/Queue;
            invokeinterface java.util.Queue.poll:()Ljava/lang/Object;
            checkcast java.lang.Runnable
            dup
            astore 2 /* task */
        start local 2 // java.lang.Runnable task
        18: ifnonnull 16
        end local 2 // java.lang.Runnable task
        end local 1 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        19: .line 581
            goto 23
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
      StackMap stack: java.lang.Throwable
        20: astore 10
        21: .line 582
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.unlock:()V
        22: .line 583
            aload 10
            athrow
        23: .line 582
      StackMap locals:
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.unlock:()V
        24: .line 584
            return
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot    Name  Signature
            0   25     0    this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            2    4     1    node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            5   19     1    node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            8   13     2  buffer  [Ljava/util/concurrent/atomic/AtomicReference;
           10   11     6    slot  Ljava/util/concurrent/atomic/AtomicReference<Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;>;
           16   17     2    task  Ljava/lang/Runnable;
           18   19     2    task  Ljava/lang/Runnable;
      Exception table:
        from    to  target  type
           1    20      20  any

  public boolean containsKey(java.lang.Object);
    descriptor: (Ljava/lang/Object;)Z
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
         0: .line 588
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 1 /* key */
            invokeinterface java.util.concurrent.ConcurrentMap.containsKey:(Ljava/lang/Object;)Z
            ireturn
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    1     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    1     1   key  Ljava/lang/Object;
    MethodParameters:
      Name  Flags
      key   

  public boolean containsValue(java.lang.Object);
    descriptor: (Ljava/lang/Object;)Z
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object value
         0: .line 593
            aload 1 /* value */
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkNotNull:(Ljava/lang/Object;)V
         1: .line 595
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            invokeinterface java.util.concurrent.ConcurrentMap.values:()Ljava/util/Collection;
            invokeinterface java.util.Collection.iterator:()Ljava/util/Iterator;
            astore 3
            goto 5
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap java.lang.Object top java.util.Iterator
      StackMap stack:
         2: aload 3
            invokeinterface java.util.Iterator.next:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 2 /* node */
        start local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         3: .line 596
            aload 2 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.getValue:()Ljava/lang/Object;
            aload 1 /* value */
            invokevirtual java.lang.Object.equals:(Ljava/lang/Object;)Z
            ifeq 5
         4: .line 597
            iconst_1
            ireturn
        end local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         5: .line 595
      StackMap locals:
      StackMap stack:
            aload 3
            invokeinterface java.util.Iterator.hasNext:()Z
            ifne 2
         6: .line 600
            iconst_0
            ireturn
        end local 1 // java.lang.Object value
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot   Name  Signature
            0    7     0   this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    7     1  value  Ljava/lang/Object;
            3    5     2   node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
    MethodParameters:
       Name  Flags
      value  

  public V get();
    descriptor: (Ljava/lang/Object;)Ljava/lang/Object;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
         0: .line 605
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 1 /* key */
            invokeinterface java.util.concurrent.ConcurrentMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 2 /* node */
        start local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         1: .line 606
            aload 2 /* node */
            ifnonnull 3
         2: .line 607
            aconst_null
            areturn
         3: .line 609
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            aload 0 /* this */
            aload 2 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterRead:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
         4: .line 610
            aload 2 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.getValue:()Ljava/lang/Object;
            areturn
        end local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    5     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    5     1   key  Ljava/lang/Object;
            1    5     2  node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
    Signature: (Ljava/lang/Object;)TV;
    MethodParameters:
      Name  Flags
      key   

  public V getQuietly();
    descriptor: (Ljava/lang/Object;)Ljava/lang/Object;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
         0: .line 625
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 1 /* key */
            invokeinterface java.util.concurrent.ConcurrentMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 2 /* node */
        start local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         1: .line 626
            aload 2 /* node */
            ifnonnull 2
            aconst_null
            goto 3
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
         2: aload 2 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.getValue:()Ljava/lang/Object;
      StackMap locals:
      StackMap stack: java.lang.Object
         3: areturn
        end local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    4     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    4     1   key  Ljava/lang/Object;
            1    4     2  node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
    Signature: (Ljava/lang/Object;)TV;
    MethodParameters:
      Name  Flags
      key   

  public V put(K, );
    descriptor: (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=4, locals=3, args_size=3
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
        start local 2 // java.lang.Object value
         0: .line 631
            aload 0 /* this */
            aload 1 /* key */
            aload 2 /* value */
            iconst_0
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.put:(Ljava/lang/Object;Ljava/lang/Object;Z)Ljava/lang/Object;
            areturn
        end local 2 // java.lang.Object value
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot   Name  Signature
            0    1     0   this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    1     1    key  TK;
            0    1     2  value  TV;
    Signature: (TK;TV;)TV;
    MethodParameters:
       Name  Flags
      key    
      value  

  public V putIfAbsent(K, );
    descriptor: (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=4, locals=3, args_size=3
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
        start local 2 // java.lang.Object value
         0: .line 636
            aload 0 /* this */
            aload 1 /* key */
            aload 2 /* value */
            iconst_1
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.put:(Ljava/lang/Object;Ljava/lang/Object;Z)Ljava/lang/Object;
            areturn
        end local 2 // java.lang.Object value
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot   Name  Signature
            0    1     0   this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    1     1    key  TK;
            0    1     2  value  TV;
    Signature: (TK;TV;)TV;
    MethodParameters:
       Name  Flags
      key    
      value  

  private V put(K, V, );
    descriptor: (Ljava/lang/Object;Ljava/lang/Object;Z)Ljava/lang/Object;
    flags: (0x0002) ACC_PRIVATE
    Code:
      stack=6, locals=10, args_size=4
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
        start local 2 // java.lang.Object value
        start local 3 // boolean onlyIfAbsent
         0: .line 650
            aload 1 /* key */
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkNotNull:(Ljava/lang/Object;)V
         1: .line 651
            aload 2 /* value */
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkNotNull:(Ljava/lang/Object;)V
         2: .line 653
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weigher:Lio/micronaut/core/util/clhm/EntryWeigher;
            aload 1 /* key */
            aload 2 /* value */
            invokeinterface io.micronaut.core.util.clhm.EntryWeigher.weightOf:(Ljava/lang/Object;Ljava/lang/Object;)I
            istore 4 /* weight */
        start local 4 // int weight
         3: .line 654
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            dup
            aload 2 /* value */
            iload 4 /* weight */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.<init>:(Ljava/lang/Object;I)V
            astore 5 /* weightedValue */
        start local 5 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
         4: .line 655
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            dup
            aload 1 /* key */
            aload 5 /* weightedValue */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.<init>:(Ljava/lang/Object;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue;)V
            astore 6 /* node */
        start local 6 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         5: .line 658
      StackMap locals: int io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 6 /* node */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.key:Ljava/lang/Object;
            aload 6 /* node */
            invokeinterface java.util.concurrent.ConcurrentMap.putIfAbsent:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 7 /* prior */
        start local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node prior
         6: .line 659
            aload 7 /* prior */
            ifnonnull 9
         7: .line 660
            aload 0 /* this */
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$AddTask
            dup
            aload 0 /* this */
            aload 6 /* node */
            iload 4 /* weight */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$AddTask.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;I)V
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterWrite:(Ljava/lang/Runnable;)V
         8: .line 661
            aconst_null
            areturn
         9: .line 663
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            iload 3 /* onlyIfAbsent */
            ifeq 12
        10: .line 664
            aload 0 /* this */
            aload 7 /* prior */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterRead:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
        11: .line 665
            aload 7 /* prior */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.getValue:()Ljava/lang/Object;
            areturn
        12: .line 668
      StackMap locals:
      StackMap stack:
            aload 7 /* prior */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.get:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            astore 8 /* oldWeightedValue */
        start local 8 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue oldWeightedValue
        13: .line 669
            aload 8 /* oldWeightedValue */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.isAlive:()Z
            ifne 15
        14: .line 670
            goto 5
        15: .line 673
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
      StackMap stack:
            aload 7 /* prior */
            aload 8 /* oldWeightedValue */
            aload 5 /* weightedValue */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.compareAndSet:(Ljava/lang/Object;Ljava/lang/Object;)Z
            ifeq 12
        16: .line 674
            iload 4 /* weight */
            aload 8 /* oldWeightedValue */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.weight:I
            isub
            istore 9 /* weightedDifference */
        start local 9 // int weightedDifference
        17: .line 675
            iload 9 /* weightedDifference */
            ifne 20
        18: .line 676
            aload 0 /* this */
            aload 7 /* prior */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterRead:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
        19: .line 677
            goto 21
        20: .line 678
      StackMap locals: int
      StackMap stack:
            aload 0 /* this */
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$UpdateTask
            dup
            aload 0 /* this */
            aload 7 /* prior */
            iload 9 /* weightedDifference */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$UpdateTask.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;I)V
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterWrite:(Ljava/lang/Runnable;)V
        21: .line 680
      StackMap locals:
      StackMap stack:
            aload 8 /* oldWeightedValue */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.value:Ljava/lang/Object;
            areturn
        end local 9 // int weightedDifference
        end local 8 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue oldWeightedValue
        end local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node prior
        end local 6 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 5 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
        end local 4 // int weight
        end local 3 // boolean onlyIfAbsent
        end local 2 // java.lang.Object value
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot                Name  Signature
            0   22     0                this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0   22     1                 key  TK;
            0   22     2               value  TV;
            0   22     3        onlyIfAbsent  Z
            3   22     4              weight  I
            4   22     5       weightedValue  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
            5   22     6                node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            6   22     7               prior  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
           13   22     8    oldWeightedValue  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
           17   22     9  weightedDifference  I
    Signature: (TK;TV;Z)TV;
    MethodParameters:
              Name  Flags
      key           
      value         
      onlyIfAbsent  

  public V computeIfAbsent(K, java.util.function.Function<? super K, ? extends V>);
    descriptor: (Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=4, locals=3, args_size=3
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
        start local 2 // java.util.function.Function mappingFunction
         0: .line 710
            aload 0 /* this */
            aload 1 /* key */
            aload 2 /* mappingFunction */
            iconst_1
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.compute:(Ljava/lang/Object;Ljava/util/function/Function;Z)Ljava/lang/Object;
            areturn
        end local 2 // java.util.function.Function mappingFunction
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot             Name  Signature
            0    1     0             this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    1     1              key  TK;
            0    1     2  mappingFunction  Ljava/util/function/Function<-TK;+TV;>;
    Signature: (TK;Ljava/util/function/Function<-TK;+TV;>;)TV;
    MethodParameters:
                 Name  Flags
      key              
      mappingFunction  

  private V compute(K, java.util.function.Function<? super K, ? extends V>, );
    descriptor: (Ljava/lang/Object;Ljava/util/function/Function;Z)Ljava/lang/Object;
    flags: (0x0002) ACC_PRIVATE
    Code:
      stack=6, locals=12, args_size=4
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
        start local 2 // java.util.function.Function mappingFunction
        start local 3 // boolean onlyIfAbsent
         0: .line 714
            aload 1 /* key */
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkNotNull:(Ljava/lang/Object;)V
         1: .line 715
            aload 2 /* mappingFunction */
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkNotNull:(Ljava/lang/Object;)V
         2: .line 717
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ObjectHolder
            dup
            aload 0 /* this */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ObjectHolder.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;)V
            astore 4 /* objectHolder */
        start local 4 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ObjectHolder objectHolder
         3: .line 720
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ObjectHolder
      StackMap stack:
            aload 0 /* this */
            aload 2 /* mappingFunction */
            aload 1 /* key */
            aload 4 /* objectHolder */
            invokedynamic apply(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;Ljava/util/function/Function;Ljava/lang/Object;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$ObjectHolder;)Ljava/util/function/Function;
              Bootstrap: invokestatic java.lang.invoke.LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
                Method arguments:
                  (Ljava/lang/Object;)Ljava/lang/Object;
                  io/micronaut/core/util/clhm/ConcurrentLinkedHashMap.lambda$0(Ljava/util/function/Function;Ljava/lang/Object;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$ObjectHolder;Ljava/lang/Object;)Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node; (7)
                  (Ljava/lang/Object;)Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;
            astore 5 /* f */
        start local 5 // java.util.function.Function f
         4: .line 733
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 1 /* key */
            aload 5 /* f */
            invokeinterface java.util.concurrent.ConcurrentMap.computeIfAbsent:(Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 6 /* prior */
        start local 6 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node prior
         5: .line 735
            aload 4 /* objectHolder */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ObjectHolder.getObject:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 7 /* node */
        start local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         6: .line 736
            aload 7 /* node */
            ifnonnull 12
         7: .line 737
            aload 6 /* prior */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.getValue:()Ljava/lang/Object;
            astore 8 /* value */
        start local 8 // java.lang.Object value
         8: .line 738
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weigher:Lio/micronaut/core/util/clhm/EntryWeigher;
            aload 1 /* key */
            aload 8 /* value */
            invokeinterface io.micronaut.core.util.clhm.EntryWeigher.weightOf:(Ljava/lang/Object;Ljava/lang/Object;)I
            istore 9 /* weight */
        start local 9 // int weight
         9: .line 739
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            dup
            aload 8 /* value */
            iload 9 /* weight */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.<init>:(Ljava/lang/Object;I)V
            astore 10 /* weightedValue */
        start local 10 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
        10: .line 740
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            dup
            aload 1 /* key */
            aload 10 /* weightedValue */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.<init>:(Ljava/lang/Object;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue;)V
            astore 7 /* node */
        end local 10 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
        end local 9 // int weight
        end local 8 // java.lang.Object value
        11: .line 741
            goto 13
        12: .line 745
      StackMap locals: java.util.function.Function io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            aconst_null
            astore 6 /* prior */
        13: .line 747
      StackMap locals:
      StackMap stack:
            aload 7 /* node */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.weightedValue:Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue;
            astore 8 /* weightedValue */
        start local 8 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
        14: .line 748
            aload 8 /* weightedValue */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.weight:I
            istore 9 /* weight */
        start local 9 // int weight
        15: .line 750
            aload 6 /* prior */
            ifnonnull 18
        16: .line 751
            aload 0 /* this */
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$AddTask
            dup
            aload 0 /* this */
            aload 7 /* node */
            iload 9 /* weight */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$AddTask.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;I)V
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterWrite:(Ljava/lang/Runnable;)V
        17: .line 752
            aload 8 /* weightedValue */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.value:Ljava/lang/Object;
            areturn
        18: .line 754
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue int
      StackMap stack:
            iload 3 /* onlyIfAbsent */
            ifeq 21
        19: .line 755
            aload 0 /* this */
            aload 6 /* prior */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterRead:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
        20: .line 756
            aload 6 /* prior */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.getValue:()Ljava/lang/Object;
            areturn
        21: .line 759
      StackMap locals:
      StackMap stack:
            aload 6 /* prior */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.get:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            astore 10 /* oldWeightedValue */
        start local 10 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue oldWeightedValue
        22: .line 760
            aload 10 /* oldWeightedValue */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.isAlive:()Z
            ifne 24
        23: .line 761
            goto 3
        24: .line 764
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
      StackMap stack:
            aload 6 /* prior */
            aload 10 /* oldWeightedValue */
            aload 8 /* weightedValue */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.compareAndSet:(Ljava/lang/Object;Ljava/lang/Object;)Z
            ifeq 21
        25: .line 765
            iload 9 /* weight */
            aload 10 /* oldWeightedValue */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.weight:I
            isub
            istore 11 /* weightedDifference */
        start local 11 // int weightedDifference
        26: .line 766
            iload 11 /* weightedDifference */
            ifne 29
        27: .line 767
            aload 0 /* this */
            aload 6 /* prior */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterRead:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
        28: .line 768
            goto 30
        29: .line 769
      StackMap locals: int
      StackMap stack:
            aload 0 /* this */
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$UpdateTask
            dup
            aload 0 /* this */
            aload 6 /* prior */
            iload 11 /* weightedDifference */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$UpdateTask.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;I)V
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterWrite:(Ljava/lang/Runnable;)V
        30: .line 771
      StackMap locals:
      StackMap stack:
            aload 10 /* oldWeightedValue */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.value:Ljava/lang/Object;
            areturn
        end local 11 // int weightedDifference
        end local 10 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue oldWeightedValue
        end local 9 // int weight
        end local 8 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
        end local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 6 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node prior
        end local 5 // java.util.function.Function f
        end local 4 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ObjectHolder objectHolder
        end local 3 // boolean onlyIfAbsent
        end local 2 // java.util.function.Function mappingFunction
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot                Name  Signature
            0   31     0                this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0   31     1                 key  TK;
            0   31     2     mappingFunction  Ljava/util/function/Function<-TK;+TV;>;
            0   31     3        onlyIfAbsent  Z
            3   31     4        objectHolder  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>.ObjectHolder<Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;>;
            4   31     5                   f  Ljava/util/function/Function<TK;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;>;
            5   31     6               prior  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            6   31     7                node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            8   11     8               value  TV;
            9   11     9              weight  I
           10   11    10       weightedValue  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
           14   31     8       weightedValue  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
           15   31     9              weight  I
           22   31    10    oldWeightedValue  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
           26   31    11  weightedDifference  I
    Signature: (TK;Ljava/util/function/Function<-TK;+TV;>;Z)TV;
    MethodParameters:
                 Name  Flags
      key              final
      mappingFunction  final
      onlyIfAbsent     

  public V remove();
    descriptor: (Ljava/lang/Object;)Ljava/lang/Object;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=5, locals=3, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
         0: .line 779
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 1 /* key */
            invokeinterface java.util.concurrent.ConcurrentMap.remove:(Ljava/lang/Object;)Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 2 /* node */
        start local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         1: .line 780
            aload 2 /* node */
            ifnonnull 3
         2: .line 781
            aconst_null
            areturn
         3: .line 784
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            aload 0 /* this */
            aload 2 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.makeRetired:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
         4: .line 785
            aload 0 /* this */
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$RemovalTask
            dup
            aload 0 /* this */
            aload 2 /* node */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$RemovalTask.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterWrite:(Ljava/lang/Runnable;)V
         5: .line 786
            aload 2 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.getValue:()Ljava/lang/Object;
            areturn
        end local 2 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    6     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    6     1   key  Ljava/lang/Object;
            1    6     2  node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
    Signature: (Ljava/lang/Object;)TV;
    MethodParameters:
      Name  Flags
      key   

  public boolean remove(java.lang.Object, java.lang.Object);
    descriptor: (Ljava/lang/Object;Ljava/lang/Object;)Z
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=5, locals=5, args_size=3
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
        start local 2 // java.lang.Object value
         0: .line 791
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 1 /* key */
            invokeinterface java.util.concurrent.ConcurrentMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 3 /* node */
        start local 3 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         1: .line 792
            aload 3 /* node */
            ifnull 2
            aload 2 /* value */
            ifnonnull 3
         2: .line 793
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            iconst_0
            ireturn
         3: .line 796
      StackMap locals:
      StackMap stack:
            aload 3 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.get:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            astore 4 /* weightedValue */
        start local 4 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
         4: .line 798
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
      StackMap stack:
            aload 4 /* weightedValue */
            aload 2 /* value */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.contains:(Ljava/lang/Object;)Z
            ifeq 12
         5: .line 799
            aload 0 /* this */
            aload 3 /* node */
            aload 4 /* weightedValue */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.tryToRetire:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue;)Z
            ifeq 9
         6: .line 800
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 1 /* key */
            aload 3 /* node */
            invokeinterface java.util.concurrent.ConcurrentMap.remove:(Ljava/lang/Object;Ljava/lang/Object;)Z
            ifeq 12
         7: .line 801
            aload 0 /* this */
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$RemovalTask
            dup
            aload 0 /* this */
            aload 3 /* node */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$RemovalTask.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterWrite:(Ljava/lang/Runnable;)V
         8: .line 802
            iconst_1
            ireturn
         9: .line 805
      StackMap locals:
      StackMap stack:
            aload 3 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.get:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            astore 4 /* weightedValue */
        10: .line 806
            aload 4 /* weightedValue */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.isAlive:()Z
            ifeq 12
        11: .line 809
            goto 4
        12: .line 813
      StackMap locals:
      StackMap stack:
            iconst_0
            ireturn
        end local 4 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
        end local 3 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 2 // java.lang.Object value
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot           Name  Signature
            0   13     0           this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0   13     1            key  Ljava/lang/Object;
            0   13     2          value  Ljava/lang/Object;
            1   13     3           node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            4   13     4  weightedValue  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
    MethodParameters:
       Name  Flags
      key    
      value  

  public V replace(K, );
    descriptor: (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=6, locals=8, args_size=3
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
        start local 2 // java.lang.Object value
         0: .line 819
            aload 1 /* key */
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkNotNull:(Ljava/lang/Object;)V
         1: .line 820
            aload 2 /* value */
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkNotNull:(Ljava/lang/Object;)V
         2: .line 822
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 1 /* key */
            invokeinterface java.util.concurrent.ConcurrentMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 3 /* node */
        start local 3 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         3: .line 823
            aload 3 /* node */
            ifnonnull 5
         4: .line 824
            aconst_null
            areturn
         5: .line 826
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weigher:Lio/micronaut/core/util/clhm/EntryWeigher;
            aload 1 /* key */
            aload 2 /* value */
            invokeinterface io.micronaut.core.util.clhm.EntryWeigher.weightOf:(Ljava/lang/Object;Ljava/lang/Object;)I
            istore 4 /* weight */
        start local 4 // int weight
         6: .line 827
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            dup
            aload 2 /* value */
            iload 4 /* weight */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.<init>:(Ljava/lang/Object;I)V
            astore 5 /* weightedValue */
        start local 5 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
         7: .line 829
      StackMap locals: int io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
      StackMap stack:
            aload 3 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.get:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            astore 6 /* oldWeightedValue */
        start local 6 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue oldWeightedValue
         8: .line 830
            aload 6 /* oldWeightedValue */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.isAlive:()Z
            ifne 10
         9: .line 831
            aconst_null
            areturn
        10: .line 833
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
      StackMap stack:
            aload 3 /* node */
            aload 6 /* oldWeightedValue */
            aload 5 /* weightedValue */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.compareAndSet:(Ljava/lang/Object;Ljava/lang/Object;)Z
            ifeq 7
        11: .line 834
            iload 4 /* weight */
            aload 6 /* oldWeightedValue */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.weight:I
            isub
            istore 7 /* weightedDifference */
        start local 7 // int weightedDifference
        12: .line 835
            iload 7 /* weightedDifference */
            ifne 15
        13: .line 836
            aload 0 /* this */
            aload 3 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterRead:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
        14: .line 837
            goto 16
        15: .line 838
      StackMap locals: int
      StackMap stack:
            aload 0 /* this */
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$UpdateTask
            dup
            aload 0 /* this */
            aload 3 /* node */
            iload 7 /* weightedDifference */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$UpdateTask.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;I)V
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterWrite:(Ljava/lang/Runnable;)V
        16: .line 840
      StackMap locals:
      StackMap stack:
            aload 6 /* oldWeightedValue */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.value:Ljava/lang/Object;
            areturn
        end local 7 // int weightedDifference
        end local 6 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue oldWeightedValue
        end local 5 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
        end local 4 // int weight
        end local 3 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 2 // java.lang.Object value
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot                Name  Signature
            0   17     0                this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0   17     1                 key  TK;
            0   17     2               value  TV;
            3   17     3                node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            6   17     4              weight  I
            7   17     5       weightedValue  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
            8   17     6    oldWeightedValue  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
           12   17     7  weightedDifference  I
    Signature: (TK;TV;)TV;
    MethodParameters:
       Name  Flags
      key    
      value  

  public boolean replace(K, V, );
    descriptor: (Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=6, locals=9, args_size=4
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.lang.Object key
        start local 2 // java.lang.Object oldValue
        start local 3 // java.lang.Object newValue
         0: .line 847
            aload 1 /* key */
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkNotNull:(Ljava/lang/Object;)V
         1: .line 848
            aload 2 /* oldValue */
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkNotNull:(Ljava/lang/Object;)V
         2: .line 849
            aload 3 /* newValue */
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkNotNull:(Ljava/lang/Object;)V
         3: .line 852
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.data:Ljava/util/concurrent/ConcurrentMap;
            aload 1 /* key */
            invokeinterface java.util.concurrent.ConcurrentMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 4 /* node */
        start local 4 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         4: .line 853
            aload 4 /* node */
            ifnonnull 6
         5: .line 854
            iconst_0
            ireturn
         6: .line 856
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weigher:Lio/micronaut/core/util/clhm/EntryWeigher;
            aload 1 /* key */
            aload 3 /* newValue */
            invokeinterface io.micronaut.core.util.clhm.EntryWeigher.weightOf:(Ljava/lang/Object;Ljava/lang/Object;)I
            istore 5 /* weight */
        start local 5 // int weight
         7: .line 857
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            dup
            aload 3 /* newValue */
            iload 5 /* weight */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.<init>:(Ljava/lang/Object;I)V
            astore 6 /* newWeightedValue */
        start local 6 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue newWeightedValue
         8: .line 859
      StackMap locals: int io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
      StackMap stack:
            aload 4 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.get:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            astore 7 /* weightedValue */
        start local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
         9: .line 860
            aload 7 /* weightedValue */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.isAlive:()Z
            ifeq 10
            aload 7 /* weightedValue */
            aload 2 /* oldValue */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.contains:(Ljava/lang/Object;)Z
            ifne 11
        10: .line 861
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
      StackMap stack:
            iconst_0
            ireturn
        11: .line 863
      StackMap locals:
      StackMap stack:
            aload 4 /* node */
            aload 7 /* weightedValue */
            aload 6 /* newWeightedValue */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.compareAndSet:(Ljava/lang/Object;Ljava/lang/Object;)Z
            ifeq 8
        12: .line 864
            iload 5 /* weight */
            aload 7 /* weightedValue */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.weight:I
            isub
            istore 8 /* weightedDifference */
        start local 8 // int weightedDifference
        13: .line 865
            iload 8 /* weightedDifference */
            ifne 16
        14: .line 866
            aload 0 /* this */
            aload 4 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterRead:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;)V
        15: .line 867
            goto 17
        16: .line 868
      StackMap locals: int
      StackMap stack:
            aload 0 /* this */
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$UpdateTask
            dup
            aload 0 /* this */
            aload 4 /* node */
            iload 8 /* weightedDifference */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$UpdateTask.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;I)V
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.afterWrite:(Ljava/lang/Runnable;)V
        17: .line 870
      StackMap locals:
      StackMap stack:
            iconst_1
            ireturn
        end local 8 // int weightedDifference
        end local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
        end local 6 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue newWeightedValue
        end local 5 // int weight
        end local 4 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 3 // java.lang.Object newValue
        end local 2 // java.lang.Object oldValue
        end local 1 // java.lang.Object key
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot                Name  Signature
            0   18     0                this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0   18     1                 key  TK;
            0   18     2            oldValue  TV;
            0   18     3            newValue  TV;
            4   18     4                node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
            7   18     5              weight  I
            8   18     6    newWeightedValue  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
            9   18     7       weightedValue  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
           13   18     8  weightedDifference  I
    Signature: (TK;TV;TV;)Z
    MethodParameters:
          Name  Flags
      key       
      oldValue  
      newValue  

  public java.util.Set<K> keySet();
    descriptor: ()Ljava/util/Set;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=4, locals=2, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 877
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.keySet:Ljava/util/Set;
            astore 1 /* ks */
        start local 1 // java.util.Set ks
         1: .line 878
            aload 1 /* ks */
            ifnonnull 4
         2: .line 879
            aload 0 /* this */
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$KeySet
            dup
            aload 0 /* this */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$KeySet.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;)V
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.keySet:Ljava/util/Set;
         3: .line 880
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.keySet:Ljava/util/Set;
            areturn
         4: .line 882
      StackMap locals: java.util.Set
      StackMap stack:
            aload 1 /* ks */
            areturn
        end local 1 // java.util.Set ks
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    5     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            1    5     1    ks  Ljava/util/Set<TK;>;
    Signature: ()Ljava/util/Set<TK;>;

  public java.util.Set<K> ascendingKeySet();
    descriptor: ()Ljava/util/Set;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 899
            aload 0 /* this */
            ldc 2147483647
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.ascendingKeySetWithLimit:(I)Ljava/util/Set;
            areturn
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    1     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
    Signature: ()Ljava/util/Set<TK;>;

  public java.util.Set<K> ascendingKeySetWithLimit(int);
    descriptor: (I)Ljava/util/Set;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=3, locals=2, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // int limit
         0: .line 918
            aload 0 /* this */
            iconst_1
            iload 1 /* limit */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.orderedKeySet:(ZI)Ljava/util/Set;
            areturn
        end local 1 // int limit
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot   Name  Signature
            0    1     0   this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    1     1  limit  I
    Signature: (I)Ljava/util/Set<TK;>;
    MethodParameters:
       Name  Flags
      limit  

  public java.util.Set<K> descendingKeySet();
    descriptor: ()Ljava/util/Set;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 935
            aload 0 /* this */
            ldc 2147483647
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.descendingKeySetWithLimit:(I)Ljava/util/Set;
            areturn
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    1     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
    Signature: ()Ljava/util/Set<TK;>;

  public java.util.Set<K> descendingKeySetWithLimit(int);
    descriptor: (I)Ljava/util/Set;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=3, locals=2, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // int limit
         0: .line 954
            aload 0 /* this */
            iconst_0
            iload 1 /* limit */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.orderedKeySet:(ZI)Ljava/util/Set;
            areturn
        end local 1 // int limit
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot   Name  Signature
            0    1     0   this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    1     1  limit  I
    Signature: (I)Ljava/util/Set<TK;>;
    MethodParameters:
       Name  Flags
      limit  

  java.lang.Object writeReplace();
    descriptor: ()Ljava/lang/Object;
    flags: (0x0000) 
    Code:
      stack=3, locals=1, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 965
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$SerializationProxy
            dup
            aload 0 /* this */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$SerializationProxy.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;)V
            areturn
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    1     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;

  private void readObject(java.io.ObjectInputStream);
    descriptor: (Ljava/io/ObjectInputStream;)V
    flags: (0x0002) ACC_PRIVATE
    Code:
      stack=3, locals=2, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // java.io.ObjectInputStream stream
         0: .line 969
            new java.io.InvalidObjectException
            dup
            ldc "Proxy required"
            invokespecial java.io.InvalidObjectException.<init>:(Ljava/lang/String;)V
            athrow
        end local 1 // java.io.ObjectInputStream stream
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot    Name  Signature
            0    1     0    this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    1     1  stream  Ljava/io/ObjectInputStream;
    Exceptions:
      throws java.io.InvalidObjectException
    MethodParameters:
        Name  Flags
      stream  

  private java.util.Set<K> orderedKeySet(boolean, int);
    descriptor: (ZI)Ljava/util/Set;
    flags: (0x0002) ACC_PRIVATE
    Code:
      stack=3, locals=8, args_size=3
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // boolean ascending
        start local 2 // int limit
         0: .line 973
            iload 2 /* limit */
            iflt 1
            iconst_1
            goto 2
      StackMap locals:
      StackMap stack:
         1: iconst_0
      StackMap locals:
      StackMap stack: int
         2: invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkArgument:(Z)V
         3: .line 974
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.lock:()V
         4: .line 976
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainBuffers:()V
         5: .line 978
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weigher:Lio/micronaut/core/util/clhm/EntryWeigher;
            invokestatic io.micronaut.core.util.clhm.Weighers.entrySingleton:()Lio/micronaut/core/util/clhm/EntryWeigher;
            if_acmpne 7
         6: .line 979
            iload 2 /* limit */
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weightedSize:()J
            l2i
            invokestatic java.lang.Math.min:(II)I
            goto 8
         7: .line 980
      StackMap locals:
      StackMap stack:
            bipush 16
         8: .line 978
      StackMap locals:
      StackMap stack: int
            istore 3 /* initialCapacity */
        start local 3 // int initialCapacity
         9: .line 981
            new java.util.LinkedHashSet
            dup
            iload 3 /* initialCapacity */
            invokespecial java.util.LinkedHashSet.<init>:(I)V
            astore 4 /* keys */
        start local 4 // java.util.Set keys
        10: .line 982
            iload 1 /* ascending */
            ifeq 12
        11: .line 983
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionDeque:Lio/micronaut/core/util/clhm/LinkedDeque;
            invokevirtual io.micronaut.core.util.clhm.LinkedDeque.iterator:()Ljava/util/Iterator;
            goto 13
        12: .line 984
      StackMap locals: int java.util.Set
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionDeque:Lio/micronaut/core/util/clhm/LinkedDeque;
            invokevirtual io.micronaut.core.util.clhm.LinkedDeque.descendingIterator:()Ljava/util/Iterator;
        13: .line 982
      StackMap locals:
      StackMap stack: java.util.Iterator
            astore 5 /* iterator */
        start local 5 // java.util.Iterator iterator
        14: .line 985
            goto 16
        15: .line 986
      StackMap locals: java.util.Iterator
      StackMap stack:
            aload 4 /* keys */
            aload 5 /* iterator */
            invokeinterface java.util.Iterator.next:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.key:Ljava/lang/Object;
            invokeinterface java.util.Set.add:(Ljava/lang/Object;)Z
            pop
        16: .line 985
      StackMap locals:
      StackMap stack:
            aload 5 /* iterator */
            invokeinterface java.util.Iterator.hasNext:()Z
            ifeq 17
            iload 2 /* limit */
            aload 4 /* keys */
            invokeinterface java.util.Set.size:()I
            if_icmpgt 15
        17: .line 988
      StackMap locals:
      StackMap stack:
            aload 4 /* keys */
            invokestatic java.util.Collections.unmodifiableSet:(Ljava/util/Set;)Ljava/util/Set;
            astore 7
        18: .line 990
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.unlock:()V
        19: .line 988
            aload 7
            areturn
        end local 5 // java.util.Iterator iterator
        end local 4 // java.util.Set keys
        end local 3 // int initialCapacity
        20: .line 989
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap int int
      StackMap stack: java.lang.Throwable
            astore 6
        21: .line 990
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.unlock:()V
        22: .line 991
            aload 6
            athrow
        end local 2 // int limit
        end local 1 // boolean ascending
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot             Name  Signature
            0   23     0             this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0   23     1        ascending  Z
            0   23     2            limit  I
            9   20     3  initialCapacity  I
           10   20     4             keys  Ljava/util/Set<TK;>;
           14   20     5         iterator  Ljava/util/Iterator<Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;>;
      Exception table:
        from    to  target  type
           4    18      20  any
    Signature: (ZI)Ljava/util/Set<TK;>;
    MethodParameters:
           Name  Flags
      ascending  
      limit      

  public java.util.Collection<V> values();
    descriptor: ()Ljava/util/Collection;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=4, locals=2, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 996
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.values:Ljava/util/Collection;
            astore 1 /* vs */
        start local 1 // java.util.Collection vs
         1: .line 997
            aload 1 /* vs */
            ifnonnull 4
         2: .line 998
            aload 0 /* this */
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Values
            dup
            aload 0 /* this */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Values.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;)V
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.values:Ljava/util/Collection;
         3: .line 999
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.values:Ljava/util/Collection;
            areturn
         4: .line 1001
      StackMap locals: java.util.Collection
      StackMap stack:
            aload 1 /* vs */
            areturn
        end local 1 // java.util.Collection vs
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    5     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            1    5     1    vs  Ljava/util/Collection<TV;>;
    Signature: ()Ljava/util/Collection<TV;>;

  public java.util.Set<java.util.Map$Entry<K, V>> entrySet();
    descriptor: ()Ljava/util/Set;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=4, locals=2, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 1006
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.entrySet:Ljava/util/Set;
            astore 1 /* es */
        start local 1 // java.util.Set es
         1: .line 1007
            aload 1 /* es */
            ifnonnull 4
         2: .line 1008
            aload 0 /* this */
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$EntrySet
            dup
            aload 0 /* this */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$EntrySet.<init>:(Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap;)V
            putfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.entrySet:Ljava/util/Set;
         3: .line 1009
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.entrySet:Ljava/util/Set;
            areturn
         4: .line 1011
      StackMap locals: java.util.Set
      StackMap stack:
            aload 1 /* es */
            areturn
        end local 1 // java.util.Set es
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    5     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            1    5     1    es  Ljava/util/Set<Ljava/util/Map$Entry<TK;TV;>;>;
    Signature: ()Ljava/util/Set<Ljava/util/Map$Entry<TK;TV;>;>;

  public java.util.Map<K, V> ascendingMap();
    descriptor: ()Ljava/util/Map;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 1029
            aload 0 /* this */
            ldc 2147483647
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.ascendingMapWithLimit:(I)Ljava/util/Map;
            areturn
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    1     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
    Signature: ()Ljava/util/Map<TK;TV;>;

  public java.util.Map<K, V> ascendingMapWithLimit(int);
    descriptor: (I)Ljava/util/Map;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=3, locals=2, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // int limit
         0: .line 1049
            aload 0 /* this */
            iconst_1
            iload 1 /* limit */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.orderedMap:(ZI)Ljava/util/Map;
            areturn
        end local 1 // int limit
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot   Name  Signature
            0    1     0   this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    1     1  limit  I
    Signature: (I)Ljava/util/Map<TK;TV;>;
    MethodParameters:
       Name  Flags
      limit  

  public java.util.Map<K, V> descendingMap();
    descriptor: ()Ljava/util/Map;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
         0: .line 1067
            aload 0 /* this */
            ldc 2147483647
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.descendingMapWithLimit:(I)Ljava/util/Map;
            areturn
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot  Name  Signature
            0    1     0  this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
    Signature: ()Ljava/util/Map<TK;TV;>;

  public java.util.Map<K, V> descendingMapWithLimit(int);
    descriptor: (I)Ljava/util/Map;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=3, locals=2, args_size=2
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // int limit
         0: .line 1087
            aload 0 /* this */
            iconst_0
            iload 1 /* limit */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.orderedMap:(ZI)Ljava/util/Map;
            areturn
        end local 1 // int limit
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot   Name  Signature
            0    1     0   this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    1     1  limit  I
    Signature: (I)Ljava/util/Map<TK;TV;>;
    MethodParameters:
       Name  Flags
      limit  

  private java.util.Map<K, V> orderedMap(boolean, int);
    descriptor: (ZI)Ljava/util/Map;
    flags: (0x0002) ACC_PRIVATE
    Code:
      stack=3, locals=9, args_size=3
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 1 // boolean ascending
        start local 2 // int limit
         0: .line 1091
            iload 2 /* limit */
            iflt 1
            iconst_1
            goto 2
      StackMap locals:
      StackMap stack:
         1: iconst_0
      StackMap locals:
      StackMap stack: int
         2: invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkArgument:(Z)V
         3: .line 1092
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.lock:()V
         4: .line 1094
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.drainBuffers:()V
         5: .line 1096
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weigher:Lio/micronaut/core/util/clhm/EntryWeigher;
            invokestatic io.micronaut.core.util.clhm.Weighers.entrySingleton:()Lio/micronaut/core/util/clhm/EntryWeigher;
            if_acmpne 7
         6: .line 1097
            iload 2 /* limit */
            aload 0 /* this */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weightedSize:()J
            l2i
            invokestatic java.lang.Math.min:(II)I
            goto 8
         7: .line 1098
      StackMap locals:
      StackMap stack:
            bipush 16
         8: .line 1096
      StackMap locals:
      StackMap stack: int
            istore 3 /* initialCapacity */
        start local 3 // int initialCapacity
         9: .line 1099
            new java.util.LinkedHashMap
            dup
            iload 3 /* initialCapacity */
            invokespecial java.util.LinkedHashMap.<init>:(I)V
            astore 4 /* map */
        start local 4 // java.util.Map map
        10: .line 1100
            iload 1 /* ascending */
            ifeq 12
        11: .line 1101
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionDeque:Lio/micronaut/core/util/clhm/LinkedDeque;
            invokevirtual io.micronaut.core.util.clhm.LinkedDeque.iterator:()Ljava/util/Iterator;
            goto 13
        12: .line 1102
      StackMap locals: int java.util.Map
      StackMap stack:
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionDeque:Lio/micronaut/core/util/clhm/LinkedDeque;
            invokevirtual io.micronaut.core.util.clhm.LinkedDeque.descendingIterator:()Ljava/util/Iterator;
        13: .line 1100
      StackMap locals:
      StackMap stack: java.util.Iterator
            astore 5 /* iterator */
        start local 5 // java.util.Iterator iterator
        14: .line 1103
            goto 17
        15: .line 1104
      StackMap locals: java.util.Iterator
      StackMap stack:
            aload 5 /* iterator */
            invokeinterface java.util.Iterator.next:()Ljava/lang/Object;
            checkcast io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            astore 6 /* node */
        start local 6 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        16: .line 1105
            aload 4 /* map */
            aload 6 /* node */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.key:Ljava/lang/Object;
            aload 6 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.getValue:()Ljava/lang/Object;
            invokeinterface java.util.Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
            pop
        end local 6 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        17: .line 1103
      StackMap locals:
      StackMap stack:
            aload 5 /* iterator */
            invokeinterface java.util.Iterator.hasNext:()Z
            ifeq 18
            iload 2 /* limit */
            aload 4 /* map */
            invokeinterface java.util.Map.size:()I
            if_icmpgt 15
        18: .line 1107
      StackMap locals:
      StackMap stack:
            aload 4 /* map */
            invokestatic java.util.Collections.unmodifiableMap:(Ljava/util/Map;)Ljava/util/Map;
            astore 8
        19: .line 1109
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.unlock:()V
        20: .line 1107
            aload 8
            areturn
        end local 5 // java.util.Iterator iterator
        end local 4 // java.util.Map map
        end local 3 // int initialCapacity
        21: .line 1108
      StackMap locals: io.micronaut.core.util.clhm.ConcurrentLinkedHashMap int int
      StackMap stack: java.lang.Throwable
            astore 7
        22: .line 1109
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.evictionLock:Ljava/util/concurrent/locks/Lock;
            invokeinterface java.util.concurrent.locks.Lock.unlock:()V
        23: .line 1110
            aload 7
            athrow
        end local 2 // int limit
        end local 1 // boolean ascending
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot             Name  Signature
            0   24     0             this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0   24     1        ascending  Z
            0   24     2            limit  I
            9   21     3  initialCapacity  I
           10   21     4              map  Ljava/util/Map<TK;TV;>;
           14   21     5         iterator  Ljava/util/Iterator<Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;>;
           16   17     6             node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
      Exception table:
        from    to  target  type
           4    19      21  any
    Signature: (ZI)Ljava/util/Map<TK;TV;>;
    MethodParameters:
           Name  Flags
      ascending  
      limit      

  private io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node lambda$0(java.util.function.Function, java.lang.Object, io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ObjectHolder, java.lang.Object);
    descriptor: (Ljava/util/function/Function;Ljava/lang/Object;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$ObjectHolder;Ljava/lang/Object;)Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node;
    flags: (0x1002) ACC_PRIVATE, ACC_SYNTHETIC
    Code:
      stack=4, locals=9, args_size=5
        start local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
        start local 4 // java.lang.Object k
         0: .line 721
            aload 1
            aload 2
            invokeinterface java.util.function.Function.apply:(Ljava/lang/Object;)Ljava/lang/Object;
            astore 5 /* value */
        start local 5 // java.lang.Object value
         1: .line 723
            aload 5 /* value */
            invokestatic io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.checkNotNull:(Ljava/lang/Object;)V
         2: .line 725
            aload 0 /* this */
            getfield io.micronaut.core.util.clhm.ConcurrentLinkedHashMap.weigher:Lio/micronaut/core/util/clhm/EntryWeigher;
            aload 2
            aload 5 /* value */
            invokeinterface io.micronaut.core.util.clhm.EntryWeigher.weightOf:(Ljava/lang/Object;Ljava/lang/Object;)I
            istore 6 /* weight */
        start local 6 // int weight
         3: .line 726
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue
            dup
            aload 5 /* value */
            iload 6 /* weight */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue.<init>:(Ljava/lang/Object;I)V
            astore 7 /* weightedValue */
        start local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
         4: .line 727
            new io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node
            dup
            aload 2
            aload 7 /* weightedValue */
            invokespecial io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node.<init>:(Ljava/lang/Object;Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue;)V
            astore 8 /* node */
        start local 8 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
         5: .line 729
            aload 3
            aload 8 /* node */
            invokevirtual io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ObjectHolder.setObject:(Ljava/lang/Object;)V
         6: .line 731
            aload 8 /* node */
            areturn
        end local 8 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node node
        end local 7 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue weightedValue
        end local 6 // int weight
        end local 5 // java.lang.Object value
        end local 4 // java.lang.Object k
        end local 0 // io.micronaut.core.util.clhm.ConcurrentLinkedHashMap this
      LocalVariableTable:
        Start  End  Slot           Name  Signature
            0    7     0           this  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap<TK;TV;>;
            0    7     4              k  TK;
            1    7     5          value  TV;
            3    7     6         weight  I
            4    7     7  weightedValue  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$WeightedValue<TV;>;
            5    7     8           node  Lio/micronaut/core/util/clhm/ConcurrentLinkedHashMap$Node<TK;TV;>;
}
Signature: <K:Ljava/lang/Object;V:Ljava/lang/Object;>Ljava/util/AbstractMap<TK;TV;>;Ljava/util/concurrent/ConcurrentMap<TK;TV;>;Ljava/io/Serializable;
SourceFile: "ConcurrentLinkedHashMap.java"
NestMembers:
  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$AddTask  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$BoundedEntryWeigher  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DiscardingListener  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DiscardingQueue  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus$1  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus$2  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus$3  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$EntryIterator  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$EntrySet  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$KeyIterator  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$KeySet  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ObjectHolder  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$RemovalTask  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$SerializationProxy  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$UpdateTask  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ValueIterator  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Values  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue  io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WriteThroughEntry
InnerClasses:
  private final AddTask = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$AddTask of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  private final BoundedEntryWeigher = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$BoundedEntryWeigher of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  public final Builder = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Builder of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  private final DiscardingListener = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DiscardingListener of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  private final DiscardingQueue = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DiscardingQueue of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  abstract DrainStatus = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$DrainStatus of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  final EntryIterator = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$EntryIterator of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  final EntrySet = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$EntrySet of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  final KeyIterator = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$KeyIterator of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  final KeySet = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$KeySet of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  private final Node = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Node of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  private ObjectHolder = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ObjectHolder of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  private final RemovalTask = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$RemovalTask of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  final SerializationProxy = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$SerializationProxy of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  private final UpdateTask = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$UpdateTask of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  final ValueIterator = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$ValueIterator of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  final Values = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$Values of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  private final WeightedValue = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WeightedValue of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  private final WriteThroughEntry = io.micronaut.core.util.clhm.ConcurrentLinkedHashMap$WriteThroughEntry of io.micronaut.core.util.clhm.ConcurrentLinkedHashMap
  public final Lookup = java.lang.invoke.MethodHandles$Lookup of java.lang.invoke.MethodHandles
  public abstract Entry = java.util.Map$Entry of java.util.Map
    RuntimeInvisibleAnnotations: 
      javax.annotation.concurrent.ThreadSafe()