import java.util.*;

import java.util.concurrent.*;

import java.util.regex.*;

import java.util.stream.*;

public class B {

static Object source() { return null; }

static void sink(Object obj) { }

static Object[] storeArrayElement(Object obj) { return new Object[] {obj}; }

static Set storeSetElement(Object obj) { return Set.of(obj); }

static Object readArrayElement(Object[] obj) { return obj[0]; }

static boolean readArrayElement(boolean[] obj) { return obj[0]; }

static byte readArrayElement(byte[] obj) { return obj[0]; }

static char readArrayElement(char[] obj) { return obj[0]; }

static short readArrayElement(short[] obj) { return obj[0]; }

static int readArrayElement(int[] obj) { return obj[0]; }

static long readArrayElement(long[] obj) { return obj[0]; }

static float readArrayElement(float[] obj) { return obj[0]; }

static double readArrayElement(double[] obj) { return obj[0]; }

static <T> List<T> storeElementList(T obj) { return List.of(obj); }

static <T> Enumeration<T> storeElementEnumeration(T obj) { Vector<T> v = new Vector<>(); v.add(obj); return v.elements(); }

static <T> NavigableSet<T> storeElementNavSet(T obj) { TreeSet<T> s = new TreeSet<>(); s.add(obj); return s; }

static <T> Stack<T> storeElementStack(T obj) { Stack<T> s = new Stack<>(); s.push(obj); return s; }

static <T> BlockingDeque<T> storeElementBlockingDeque(T obj) { LinkedBlockingDeque<T> q = new LinkedBlockingDeque<>(); q.add(obj); return q; }

static <T> ListIterator<T> storeElementListIterator(T obj) { return List.of(obj).listIterator(); }

static <T> T readElement(Iterable<T> obj) { return obj.iterator().next(); }

static <T> T readElement(Iterator<T> obj) { return obj.next(); }

static <T> T readElement(Spliterator<T> obj) { return null; }

static <T> T readElement(Stream<T> obj) { return null; }

static <T> T readElement(Enumeration<T> obj) { return obj.nextElement(); }

static <K,V> Map.Entry<K,V> storeMapKeyEntry(K obj) { return Map.entry(obj,null); }

static <K,V> Map<K,V> storeMapKey(K obj) { Map<K,V> m = new TreeMap<K,V>(); m.put(obj,null); return m; }

static <K,V> Map.Entry<K,V> storeMapValueEntry(V obj) { return Map.entry(null,obj); }

static <K,V> Map<K,V> storeMapValue(V obj) { Map<K,V> m = 1==1?new TreeMap<K,V>():new ConcurrentHashMap<K,V>(); m.put(null,obj); return m; }

static <K,V> K readMapKey(Map.Entry<K,V> obj) { return obj.getKey(); }

static <K,V> K readMapKey(Map<K,V> obj) { return obj.keySet().iterator().next(); }

static <K,V> K readMapKey(Dictionary<K,V> obj) { return obj.keys().nextElement(); }

static <K,V> V readMapValue(Map.Entry<K,V> obj) { return obj.getValue(); }

static <K,V> V readMapValue(Map<K,V> obj) { return obj.get(null); }

static <K,V> V readMapValue(Dictionary<K,V> obj) { return obj.get(null); }

void foo() throws InterruptedException {

{

// "java.util;Map$Entry;true;getKey;;;Argument[this].MapKey;ReturnValue;value;manual",

Object out = null;

Object in = storeMapKeyEntry(source()); out = ((Map.Entry)in).getKey(); sink(out); // $ hasValueFlow

}

{

// "java.util;Map$Entry;true;getValue;;;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValueEntry(source()); out = ((Map.Entry)in).getValue(); sink(out); // $ hasValueFlow

}

{

// "java.util;Map$Entry;true;setValue;;;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValueEntry(source()); out = ((Map.Entry)in).setValue(null); sink(out); // $ hasValueFlow

}

{

// "java.util;Map$Entry;true;setValue;;;Argument[0];Argument[this].MapValue;value;manual",

Map.Entry out = null;

Object in = source(); out.setValue(in); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.lang;Iterable;true;iterator;();;Argument[this].Element;ReturnValue.Element;value;manual",

Iterator out = null;

Iterable in = storeElementList(source()); out = in.iterator(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.lang;Iterable;true;spliterator;();;Argument[this].Element;ReturnValue.Element;value;manual",

Spliterator out = null;

Iterable in = storeElementList(source()); out = in.spliterator(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Iterator;true;next;;;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Iterator in = storeElementListIterator(source()); out = in.next(); sink(out); // $ hasValueFlow

}

{

// "java.util;ListIterator;true;previous;;;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

ListIterator in = storeElementListIterator(source()); out = in.previous(); sink(out); // $ hasValueFlow

}

{

// "java.util;ListIterator;true;add;(Object);;Argument[0];Argument[this].Element;value;manual",

ListIterator out = null;

Object in = source(); out.add(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;ListIterator;true;set;(Object);;Argument[0];Argument[this].Element;value;manual",

ListIterator out = null;

Object in = source(); out.set(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Enumeration;true;asIterator;;;Argument[this].Element;ReturnValue.Element;value;manual",

Iterator out = null;

Enumeration in = storeElementEnumeration(source()); out = in.asIterator(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Enumeration;true;nextElement;;;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Enumeration in = storeElementEnumeration(source()); out = in.nextElement(); sink(out); // $ hasValueFlow

}

{

// "java.util;Map;true;computeIfAbsent;;;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValue(source()); out = ((Map)in).computeIfAbsent(null,null); sink(out); // $ hasValueFlow

}

{

// "java.util;Map;true;computeIfAbsent;;;Argument[1].ReturnValue;ReturnValue;value;manual",

Object out = ((Map)null).computeIfAbsent(null,k -> source()); sink(out); // $ hasValueFlow

}

{

// "java.util;Map;true;computeIfAbsent;;;Argument[1].ReturnValue;Argument[this].MapValue;value;manual",

Map out = null;

out.computeIfAbsent(null,k -> source()); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;entrySet;;;Argument[this].MapValue;ReturnValue.Element.MapValue;value;manual",

Set<Map.Entry> out = null;

Object in = storeMapValue(source()); out = ((Map)in).entrySet(); sink(readMapValue(readElement(out))); // $ hasValueFlow

}

{

// "java.util;Map;true;entrySet;;;Argument[this].MapKey;ReturnValue.Element.MapKey;value;manual",

Set<Map.Entry> out = null;

Object in = storeMapKey(source()); out = ((Map)in).entrySet(); sink(readMapKey(readElement(out))); // $ hasValueFlow

}

{

// "java.util;Map;true;get;;;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValue(source()); out = ((Map)in).get(null); sink(out); // $ hasValueFlow

}

{

// "java.util;Map;true;getOrDefault;;;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValue(source()); out = ((Map)in).getOrDefault(null,null); sink(out); // $ hasValueFlow

}

{

// "java.util;Map;true;getOrDefault;;;Argument[1];ReturnValue;value;manual",

Object out = null;

Object in = source(); out = ((Map)null).getOrDefault(null,in); sink(out); // $ hasValueFlow

}

{

// "java.util;Map;true;put;;;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValue(source()); out = ((Map)in).put(null,null); sink(out); // $ hasValueFlow

}

{

// "java.util;Map;true;put;;;Argument[0];Argument[this].MapKey;value;manual",

Map out = null;

Object in = source(); out.put(in,null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;put;;;Argument[1];Argument[this].MapValue;value;manual",

Map out = null;

Object in = source(); out.put(null,in); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;putIfAbsent;;;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValue(source()); out = ((Map)in).putIfAbsent(null,null); sink(out); // $ hasValueFlow

}

{

// "java.util;Map;true;putIfAbsent;;;Argument[0];Argument[this].MapKey;value;manual",

Map out = null;

Object in = source(); out.putIfAbsent(in,null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;putIfAbsent;;;Argument[1];Argument[this].MapValue;value;manual",

Map out = null;

Object in = source(); out.putIfAbsent(null,in); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;remove;(Object);;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValue(source()); out = ((Map)in).remove(null); sink(out); // $ hasValueFlow

}

{

// "java.util;Map;true;replace;(Object,Object);;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValue(source()); out = ((Map)in).replace(null,null); sink(out); // $ hasValueFlow

}

{

// "java.util;Map;true;replace;(Object,Object);;Argument[0];Argument[this].MapKey;value;manual",

Map out = null;

Object in = source(); out.replace(in,null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;replace;(Object,Object);;Argument[1];Argument[this].MapValue;value;manual",

Map out = null;

Object in = source(); out.replace(null,in); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;replace;(Object,Object,Object);;Argument[0];Argument[this].MapKey;value;manual",

Map out = null;

Object in = source(); out.replace(in,null,null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;replace;(Object,Object,Object);;Argument[2];Argument[this].MapValue;value;manual",

Map out = null;

Object in = source(); out.replace(null,null,in); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;keySet;();;Argument[this].MapKey;ReturnValue.Element;value;manual",

Set out = null;

Object in = storeMapKey(source()); out = ((Map)in).keySet(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;values;();;Argument[this].MapValue;ReturnValue.Element;value;manual",

Iterable out = null;

Object in = storeMapValue(source()); out = ((Map)in).values(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;merge;(Object,Object,BiFunction);;Argument[1];Argument[this].MapValue;value;manual",

Map out = null;

Object in = source(); out.merge(null,in,null); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;putAll;(Map);;Argument[0].MapKey;Argument[this].MapKey;value;manual",

Map out = null;

Object in = storeMapKey(source()); out.putAll((Map)in); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;Map;true;putAll;(Map);;Argument[0].MapValue;Argument[this].MapValue;value;manual",

Map out = null;

Object in = storeMapValue(source()); out.putAll((Map)in); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;Collection;true;parallelStream;();;Argument[this].Element;ReturnValue.Element;value;manual",

Stream out = null;

Collection in = storeElementList(source()); out = in.parallelStream(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Collection;true;stream;();;Argument[this].Element;ReturnValue.Element;value;manual",

Stream out = null;

Collection in = storeElementList(source()); out = in.stream(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Collection;true;toArray;;;Argument[this].Element;ReturnValue.ArrayElement;value;manual",

Object[] out = null;

Collection in = storeElementList(source()); out = in.toArray(); sink(readArrayElement(out)); // $ hasValueFlow

}

{

// "java.util;Collection;true;toArray;;;Argument[this].Element;Argument[0].ArrayElement;value;manual",

Object[] out = null;

Collection in = storeElementList(source()); in.toArray(out); sink(readArrayElement(out)); // $ hasValueFlow

}

{

// "java.util;Collection;true;add;;;Argument[0];Argument[this].Element;value;manual",

Collection out = null;

Object in = source(); out.add(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Collection;true;addAll;;;Argument[0].Element;Argument[this].Element;value;manual",

Collection out = null;

Collection in = storeElementList(source()); out.addAll(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;true;get;(int);;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

List in = storeElementList(source()); out = in.get(0); sink(out); // $ hasValueFlow

}

{

// "java.util;List;true;listIterator;;;Argument[this].Element;ReturnValue.Element;value;manual",

ListIterator out = null;

List in = storeElementList(source()); out = in.listIterator(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;true;remove;(int);;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

List in = storeElementList(source()); out = in.remove(0); sink(out); // $ hasValueFlow

}

{

// "java.util;List;true;set;(int,Object);;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

List in = storeElementList(source()); out = in.set(0,null); sink(out); // $ hasValueFlow

}

{

// "java.util;List;true;set;(int,Object);;Argument[1];Argument[this].Element;value;manual",

List out = null;

Object in = source(); out.set(0,in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;true;subList;;;Argument[this].Element;ReturnValue.Element;value;manual",

List out = null;

List in = storeElementList(source()); out = in.subList(0,0); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;true;add;(int,Object);;Argument[1];Argument[this].Element;value;manual",

List out = null;

Object in = source(); out.add(0,in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;true;addAll;(int,Collection);;Argument[1].Element;Argument[this].Element;value;manual",

List out = null;

Collection in = storeElementList(source()); out.addAll(0,in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;true;clear;;;Argument[this].WithoutElement;Argument[this];value;manual"

List out = null;

List in = storeElementList(source()); out = in; out.clear(); sink(readElement(out)); // No flow

}

{

// "java.util;List;true;clear;;;Argument[this].WithoutElement;Argument[this];value;manual"

List out = null;

List in = (List)source(); out = in; out.clear(); sink(out); // $ hasValueFlow

}

{

// "java.util;Vector;true;elementAt;(int);;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Vector in = storeElementStack(source()); out = in.elementAt(0); sink(out); // $ hasValueFlow

}

{

// "java.util;Vector;true;elements;();;Argument[this].Element;ReturnValue.Element;value;manual",

Enumeration out = null;

Vector in = storeElementStack(source()); out = in.elements(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Vector;true;firstElement;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Vector in = storeElementStack(source()); out = in.firstElement(); sink(out); // $ hasValueFlow

}

{

// "java.util;Vector;true;lastElement;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Vector in = storeElementStack(source()); out = in.lastElement(); sink(out); // $ hasValueFlow

}

{

// "java.util;Vector;true;addElement;(Object);;Argument[0];Argument[this].Element;value;manual",

Vector out = null;

Object in = source(); out.addElement(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Vector;true;insertElementAt;(Object,int);;Argument[0];Argument[this].Element;value;manual",

Vector out = null;

Object in = source(); out.insertElementAt(in,0); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Vector;true;setElementAt;(Object,int);;Argument[0];Argument[this].Element;value;manual",

Vector out = null;

Object in = source(); out.setElementAt(in,0); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Vector;true;copyInto;(Object[]);;Argument[this].Element;Argument[0].ArrayElement;value;manual",

Object[] out = null;

Vector in = storeElementStack(source()); in.copyInto(out); sink(readArrayElement(out)); // $ hasValueFlow

}

{

// "java.util;Stack;true;peek;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Stack in = storeElementStack(source()); out = in.peek(); sink(out); // $ hasValueFlow

}

{

// "java.util;Stack;true;pop;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Stack in = storeElementStack(source()); out = in.pop(); sink(out); // $ hasValueFlow

}

{

// "java.util;Stack;true;push;(Object);;Argument[0];Argument[this].Element;value;manual",

Stack out = null;

Object in = source(); out.push(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Queue;true;element;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Queue in = storeElementBlockingDeque(source()); out = in.element(); sink(out); // $ hasValueFlow

}

{

// "java.util;Queue;true;peek;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Queue in = storeElementBlockingDeque(source()); out = in.peek(); sink(out); // $ hasValueFlow

}

{

// "java.util;Queue;true;poll;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Queue in = storeElementBlockingDeque(source()); out = in.poll(); sink(out); // $ hasValueFlow

}

{

// "java.util;Queue;true;remove;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Queue in = storeElementBlockingDeque(source()); out = in.remove(); sink(out); // $ hasValueFlow

}

{

// "java.util;Queue;true;offer;(Object);;Argument[0];Argument[this].Element;value;manual",

Queue out = null;

Object in = source(); out.offer(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Deque;true;descendingIterator;();;Argument[this].Element;ReturnValue.Element;value;manual",

Iterator out = null;

Deque in = storeElementBlockingDeque(source()); out = in.descendingIterator(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Deque;true;getFirst;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Deque in = storeElementBlockingDeque(source()); out = in.getFirst(); sink(out); // $ hasValueFlow

}

{

// "java.util;Deque;true;getLast;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Deque in = storeElementBlockingDeque(source()); out = in.getLast(); sink(out); // $ hasValueFlow

}

{

// "java.util;Deque;true;peekFirst;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Deque in = storeElementBlockingDeque(source()); out = in.peekFirst(); sink(out); // $ hasValueFlow

}

{

// "java.util;Deque;true;peekLast;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Deque in = storeElementBlockingDeque(source()); out = in.peekLast(); sink(out); // $ hasValueFlow

}

{

// "java.util;Deque;true;pollFirst;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Deque in = storeElementBlockingDeque(source()); out = in.pollFirst(); sink(out); // $ hasValueFlow

}

{

// "java.util;Deque;true;pollLast;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Deque in = storeElementBlockingDeque(source()); out = in.pollLast(); sink(out); // $ hasValueFlow

}

{

// "java.util;Deque;true;pop;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Deque in = storeElementBlockingDeque(source()); out = in.pop(); sink(out); // $ hasValueFlow

}

{

// "java.util;Deque;true;removeFirst;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Deque in = storeElementBlockingDeque(source()); out = in.removeFirst(); sink(out); // $ hasValueFlow

}

{

// "java.util;Deque;true;removeLast;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

Deque in = storeElementBlockingDeque(source()); out = in.removeLast(); sink(out); // $ hasValueFlow

}

{

// "java.util;Deque;true;push;(Object);;Argument[0];Argument[this].Element;value;manual",

Deque out = null;

Object in = source(); out.push(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Deque;true;offerLast;(Object);;Argument[0];Argument[this].Element;value;manual",

Deque out = null;

Object in = source(); out.offerLast(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Deque;true;offerFirst;(Object);;Argument[0];Argument[this].Element;value;manual",

Deque out = null;

Object in = source(); out.offerFirst(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Deque;true;addLast;(Object);;Argument[0];Argument[this].Element;value;manual",

Deque out = null;

Object in = source(); out.addLast(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Deque;true;addFirst;(Object);;Argument[0];Argument[this].Element;value;manual",

Deque out = null;

Object in = source(); out.addFirst(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingDeque;true;pollFirst;(long,TimeUnit);;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

BlockingDeque in = storeElementBlockingDeque(source()); out = in.pollFirst(0,null); sink(out); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingDeque;true;pollLast;(long,TimeUnit);;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

BlockingDeque in = storeElementBlockingDeque(source()); out = in.pollLast(0,null); sink(out); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingDeque;true;takeFirst;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

BlockingDeque in = storeElementBlockingDeque(source()); out = in.takeFirst(); sink(out); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingDeque;true;takeLast;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

BlockingDeque in = storeElementBlockingDeque(source()); out = in.takeLast(); sink(out); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingQueue;true;poll;(long,TimeUnit);;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

BlockingQueue in = storeElementBlockingDeque(source()); out = in.poll(0,null); sink(out); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingQueue;true;take;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

BlockingQueue in = storeElementBlockingDeque(source()); out = in.take(); sink(out); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingQueue;true;offer;(Object,long,TimeUnit);;Argument[0];Argument[this].Element;value;manual",

BlockingQueue out = null;

Object in = source(); out.offer(in,0,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingQueue;true;put;(Object);;Argument[0];Argument[this].Element;value;manual",

BlockingQueue out = null;

Object in = source(); out.put(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingDeque;true;offerLast;(Object,long,TimeUnit);;Argument[0];Argument[this].Element;value;manual",

BlockingDeque out = null;

Object in = source(); out.offerLast(in,0,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingDeque;true;offerFirst;(Object,long,TimeUnit);;Argument[0];Argument[this].Element;value;manual",

BlockingDeque out = null;

Object in = source(); out.offerFirst(in,0,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingDeque;true;putLast;(Object);;Argument[0];Argument[this].Element;value;manual",

BlockingDeque out = null;

Object in = source(); out.putLast(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingDeque;true;putFirst;(Object);;Argument[0];Argument[this].Element;value;manual",

BlockingDeque out = null;

Object in = source(); out.putFirst(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingQueue;true;drainTo;(Collection,int);;Argument[this].Element;Argument[0].Element;value;manual",

Collection out = null;

BlockingQueue in = storeElementBlockingDeque(source()); in.drainTo(out,0); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;BlockingQueue;true;drainTo;(Collection);;Argument[this].Element;Argument[0].Element;value;manual",

Collection out = null;

BlockingQueue in = storeElementBlockingDeque(source()); in.drainTo(out); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;ConcurrentHashMap;true;elements;();;Argument[this].MapValue;ReturnValue.Element;value;manual",

Enumeration out = null;

Object in = storeMapValue(source()); out = ((ConcurrentHashMap)in).elements(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Dictionary;true;elements;();;Argument[this].MapValue;ReturnValue.Element;value;manual",

Enumeration out = null;

Object in = storeMapValue(source()); out = ((Dictionary)in).elements(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;Dictionary;true;get;(Object);;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValue(source()); out = ((Dictionary)in).get(null); sink(out); // $ hasValueFlow

}

{

// "java.util;Dictionary;true;put;(Object,Object);;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValue(source()); out = ((Dictionary)in).put(null,null); sink(out); // $ hasValueFlow

}

{

// "java.util;Dictionary;true;put;(Object,Object);;Argument[0];Argument[this].MapKey;value;manual",

Dictionary out = null;

Object in = source(); out.put(in,null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;Dictionary;true;put;(Object,Object);;Argument[1];Argument[this].MapValue;value;manual",

Dictionary out = null;

Object in = source(); out.put(null,in); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;Dictionary;true;remove;(Object);;Argument[this].MapValue;ReturnValue;value;manual",

Object out = null;

Object in = storeMapValue(source()); out = ((Dictionary)in).remove(null); sink(out); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;ceilingEntry;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map.Entry out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).ceilingEntry(null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;ceilingEntry;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map.Entry out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).ceilingEntry(null); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;descendingMap;();;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).descendingMap(); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;descendingMap;();;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).descendingMap(); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;firstEntry;();;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map.Entry out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).firstEntry(); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;firstEntry;();;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map.Entry out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).firstEntry(); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;floorEntry;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map.Entry out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).floorEntry(null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;floorEntry;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map.Entry out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).floorEntry(null); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;headMap;(Object,boolean);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).headMap(null,true); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;headMap;(Object,boolean);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).headMap(null,true); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;higherEntry;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map.Entry out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).higherEntry(null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;higherEntry;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map.Entry out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).higherEntry(null); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;lastEntry;();;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map.Entry out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).lastEntry(); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;lastEntry;();;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map.Entry out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).lastEntry(); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;lowerEntry;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map.Entry out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).lowerEntry(null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;lowerEntry;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map.Entry out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).lowerEntry(null); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;pollFirstEntry;();;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map.Entry out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).pollFirstEntry(); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;pollFirstEntry;();;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map.Entry out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).pollFirstEntry(); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;pollLastEntry;();;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map.Entry out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).pollLastEntry(); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;pollLastEntry;();;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map.Entry out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).pollLastEntry(); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;subMap;(Object,boolean,Object,boolean);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).subMap(null,true,null,true); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;subMap;(Object,boolean,Object,boolean);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).subMap(null,true,null,true); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;tailMap;(Object,boolean);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map out = null;

Object in = storeMapKey(source()); out = ((NavigableMap)in).tailMap(null,true); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;NavigableMap;true;tailMap;(Object,boolean);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map out = null;

Object in = storeMapValue(source()); out = ((NavigableMap)in).tailMap(null,true); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;NavigableSet;true;ceiling;(Object);;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

NavigableSet in = storeElementNavSet(source()); out = in.ceiling(null); sink(out); // $ hasValueFlow

}

{

// "java.util;NavigableSet;true;descendingIterator;();;Argument[this].Element;ReturnValue.Element;value;manual",

Iterator out = null;

NavigableSet in = storeElementNavSet(source()); out = in.descendingIterator(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;NavigableSet;true;descendingSet;();;Argument[this].Element;ReturnValue.Element;value;manual",

Set out = null;

NavigableSet in = storeElementNavSet(source()); out = in.descendingSet(); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;NavigableSet;true;floor;(Object);;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

NavigableSet in = storeElementNavSet(source()); out = in.floor(null); sink(out); // $ hasValueFlow

}

{

// "java.util;NavigableSet;true;headSet;(Object,boolean);;Argument[this].Element;ReturnValue.Element;value;manual",

Set out = null;

NavigableSet in = storeElementNavSet(source()); out = in.headSet(null,true); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;NavigableSet;true;higher;(Object);;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

NavigableSet in = storeElementNavSet(source()); out = in.higher(null); sink(out); // $ hasValueFlow

}

{

// "java.util;NavigableSet;true;lower;(Object);;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

NavigableSet in = storeElementNavSet(source()); out = in.lower(null); sink(out); // $ hasValueFlow

}

{

// "java.util;NavigableSet;true;pollFirst;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

NavigableSet in = storeElementNavSet(source()); out = in.pollFirst(); sink(out); // $ hasValueFlow

}

{

// "java.util;NavigableSet;true;pollLast;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

NavigableSet in = storeElementNavSet(source()); out = in.pollLast(); sink(out); // $ hasValueFlow

}

{

// "java.util;NavigableSet;true;subSet;(Object,boolean,Object,boolean);;Argument[this].Element;ReturnValue.Element;value;manual",

Set out = null;

NavigableSet in = storeElementNavSet(source()); out = in.subSet(null,true,null,true); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;NavigableSet;true;tailSet;(Object,boolean);;Argument[this].Element;ReturnValue.Element;value;manual",

Set out = null;

NavigableSet in = storeElementNavSet(source()); out = in.tailSet(null,true); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;SortedMap;true;headMap;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map out = null;

Object in = storeMapKey(source()); out = ((SortedMap)in).headMap(null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;SortedMap;true;headMap;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map out = null;

Object in = storeMapValue(source()); out = ((SortedMap)in).headMap(null); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;SortedMap;true;subMap;(Object,Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map out = null;

Object in = storeMapKey(source()); out = ((SortedMap)in).subMap(null,null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;SortedMap;true;subMap;(Object,Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map out = null;

Object in = storeMapValue(source()); out = ((SortedMap)in).subMap(null,null); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;SortedMap;true;tailMap;(Object);;Argument[this].MapKey;ReturnValue.MapKey;value;manual",

Map out = null;

Object in = storeMapKey(source()); out = ((SortedMap)in).tailMap(null); sink(readMapKey(out)); // $ hasValueFlow

}

{

// "java.util;SortedMap;true;tailMap;(Object);;Argument[this].MapValue;ReturnValue.MapValue;value;manual",

Map out = null;

Object in = storeMapValue(source()); out = ((SortedMap)in).tailMap(null); sink(readMapValue(out)); // $ hasValueFlow

}

{

// "java.util;SortedSet;true;first;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

SortedSet in = storeElementNavSet(source()); out = in.first(); sink(out); // $ hasValueFlow

}

{

// "java.util;SortedSet;true;headSet;(Object);;Argument[this].Element;ReturnValue.Element;value;manual",

Set out = null;

SortedSet in = storeElementNavSet(source()); out = in.headSet(null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;SortedSet;true;last;();;Argument[this].Element;ReturnValue;value;manual",

Object out = null;

SortedSet in = storeElementNavSet(source()); out = in.last(); sink(out); // $ hasValueFlow

}

{

// "java.util;SortedSet;true;subSet;(Object,Object);;Argument[this].Element;ReturnValue.Element;value;manual",

Set out = null;

SortedSet in = storeElementNavSet(source()); out = in.subSet(null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;SortedSet;true;tailSet;(Object);;Argument[this].Element;ReturnValue.Element;value;manual",

Set out = null;

SortedSet in = storeElementNavSet(source()); out = in.tailSet(null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;TransferQueue;true;tryTransfer;(Object,long,TimeUnit);;Argument[0];Argument[this].Element;value;manual",

TransferQueue out = null;

Object in = source(); out.tryTransfer(in,0,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;TransferQueue;true;transfer;(Object);;Argument[0];Argument[this].Element;value;manual",

TransferQueue out = null;

Object in = source(); out.transfer(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util.concurrent;TransferQueue;true;tryTransfer;(Object);;Argument[0];Argument[this].Element;value;manual",

TransferQueue out = null;

Object in = source(); out.tryTransfer(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;copyOf;(Collection);;Argument[0].Element;ReturnValue.Element;value;manual",

List out = null;

Collection in = storeElementList(source()); out = List.copyOf(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object[]);;Argument[0].ArrayElement;ReturnValue.Element;value;manual",

List out = null;

Object[] in = storeArrayElement(source()); out = List.of(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object);;Argument[0];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object);;Argument[0];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(in,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object);;Argument[1];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(in,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,in,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(in,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,in,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,in,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(in,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,null,null,in,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object);;Argument[6];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,null,null,null,in); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[0];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(in,null,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[1];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,in,null,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[2];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,in,null,null,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[3];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,in,null,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[4];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,null,in,null,null,null); sink(readElement(out)); // $ hasValueFlow

}

{

// "java.util;List;false;of;(Object,Object,Object,Object,Object,Object,Object,Object);;Argument[5];ReturnValue.Element;value;manual",

List out = null;

Object in = source(); out = List.of(null,null,null,null,null,in,null,null); sink(readElement(out)); // $ hasValueFlow

}