package p402.p403;

import java.util.Collection;
import java.util.Iterator;
import kotlin.TypeCastException;
import p402.InterfaceC6540;
import p402.p411.p412.InterfaceC6614;
import p402.p411.p413.AbstractC6636;
import p402.p411.p413.C6632;
import p402.p411.p413.C6635;
import p402.p411.p413.p414.InterfaceC6650;

/* JADX INFO: renamed from: ގ.ފ.֏, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
@InterfaceC6540
public abstract class AbstractC6551<E> implements Collection<E>, InterfaceC6650 {

    /* JADX INFO: renamed from: ގ.ފ.֏$֏, reason: contains not printable characters */
    public static final class C6552 extends AbstractC6636 implements InterfaceC6614<E, CharSequence> {
        public C6552() {
            super(1);
        }

        @Override // p402.p411.p412.InterfaceC6614
        /* JADX INFO: renamed from: ؠ */
        public CharSequence mo1606(Object obj) {
            return obj == AbstractC6551.this ? "(this Collection)" : String.valueOf(obj);
        }
    }

    @Override // java.util.Collection
    public boolean add(E e) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Collection
    public boolean addAll(Collection<? extends E> collection) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Collection
    public void clear() {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Collection
    public boolean contains(Object obj) {
        if (isEmpty()) {
            return false;
        }
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            if (C6635.m9825(it.next(), obj)) {
                return true;
            }
        }
        return false;
    }

    @Override // java.util.Collection
    public boolean containsAll(Collection<? extends Object> collection) {
        if (collection == null) {
            C6635.m9824("elements");
            throw null;
        }
        if (collection.isEmpty()) {
            return true;
        }
        Iterator<T> it = collection.iterator();
        while (it.hasNext()) {
            if (!contains(it.next())) {
                return false;
            }
        }
        return true;
    }

    @Override // java.util.Collection
    public boolean isEmpty() {
        return mo9770() == 0;
    }

    @Override // java.util.Collection
    public boolean remove(Object obj) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Collection
    public boolean removeAll(Collection<? extends Object> collection) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Collection
    public boolean retainAll(Collection<? extends Object> collection) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Collection
    public final /* bridge */ int size() {
        return mo9770();
    }

    @Override // java.util.Collection
    public Object[] toArray() {
        return C6632.m9817(this);
    }

    @Override // java.util.Collection
    public <T> T[] toArray(T[] tArr) {
        if (tArr == null) {
            C6635.m9824("array");
            throw null;
        }
        T[] tArr2 = (T[]) C6632.m9818(this, tArr);
        if (tArr2 != null) {
            return tArr2;
        }
        throw new TypeCastException("null cannot be cast to non-null type kotlin.Array<T>");
    }

    public String toString() {
        return C6560.m9775(this, ", ", "[", "]", 0, (CharSequence) null, new C6552(), 24);
    }

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public abstract int mo9770();
}