for (int i = 0; i < n; ++i) {
        Cell a = as[i];
        if (a != null) a.value = initialValue;
      }
    }
  }

  // Unsafe mechanics
  private static final Unsafe UNSAFE;
  private static final long BASE_OFFSET;
  private static final long BUSY_OFFSET;

  static {
    try {
      UNSAFE = getUnsafe();
      Class<?> sk = Striped64.class;

    //                                                                           =========
    @Resource
    private RelatedContentService relatedContentService;
    @Resource
    private RelatedContentPager relatedContentPager;

    // ===================================================================================
    //                                                                               Hook

   *     key
   */
  public static <V> CacheLoader<Object, V> from(Supplier<V> supplier) {
    return new SupplierToCacheLoader<>(supplier);
  }

  private static final class FunctionToCacheLoader<K, V> extends CacheLoader<K, V>
      implements Serializable {
    private final Function<K, V> computingFunction;

    FunctionToCacheLoader(Function<K, V> computingFunction) {
      this.computingFunction = checkNotNull(computingFunction);

    public boolean usesFastPath() {
      return true;
    }

    // Provides load and store operations that use native instructions to get better performance.
    private static final Unsafe theUnsafe;

    // The offset to the first element in a byte array.
    private static final int BYTE_ARRAY_BASE_OFFSET;

    /**
     * Returns an Unsafe. Suitable for use in a 3rd party package. Replace with a simple call to

@NullMarked
public class RegularImmutableTableTest extends AbstractImmutableTableTest {
  private static final ImmutableSet<Cell<Character, Integer, String>> CELLS =
      ImmutableSet.of(
          immutableCell('a', 1, "foo"), immutableCell('b', 1, "bar"), immutableCell('a', 2, "baz"));

  private static final ImmutableSet<Character> ROW_SPACE = ImmutableSet.of('a', 'b');

  private static final ImmutableSet<Integer> COLUMN_SPACE = ImmutableSet.of(1, 2);

    private final AtomicInteger count = new AtomicInteger();

    @Override
    public Object load(Object from) {
      count.incrementAndGet();
      return new Object();
    }

    public int getCount() {
      return count.get();
    }
  }

  static final class ConstantLoader<K, V> extends CacheLoader<K, V> {
    private final V constant;

 */

package jcifs.smb1.netbios;

import java.io.UnsupportedEncodingException;

class NodeStatusResponse extends NameServicePacket {

    private final NbtAddress queryAddress;

    private int numberOfNames;
    private final byte[] macAddress;
    private byte[] stats;

    NbtAddress[] addressArray;

    /* It is a little awkward but prudent to pass the quering address

    /** Specify the visibility scope where Javadoc comments are checked. */
    private Scope scope = Scope.PUBLIC;

    /** Specify the visibility scope where Javadoc comments are not checked. */
    private Scope excludeScope;

    /** Specify pattern for types to ignore. */
    private Pattern ignorePattern = Pattern.compile("^$");

    /**

            return sourceRedistributionRequired;
        }
    }

    private static class LicenseMatcher {
        private final String identifier;
        private final boolean spdxLicense;
        private final boolean sourceRedistributionRequired;
        private final Pattern pattern;

 * </ul>
 *
 * @author Jim McMaster
 * @author Jige Yu
 * @since 10.0
 */
@GwtCompatible
@NullMarked
public final class EqualsTester {
  private static final int REPETITIONS = 3;

  private final List<List<Object>> equalityGroups = new ArrayList<>();
  private final RelationshipTester.ItemReporter itemReporter;

  /** Constructs an empty EqualsTester instance */
  public EqualsTester() {