this.mirroredRepositories = Collections.emptyList();
        }
    }

    @Override
    public boolean isBlocked() {
        return blocked;
    }

    @Override
    public void setBlocked(boolean blocked) {
        this.blocked = blocked;
    }

            if (mirror.getLayout() != null && !mirror.getLayout().isEmpty()) {
                repository.setLayout(original.getLayout());
            }

            repository.setBlocked(mirror.isBlocked());
        }
    }

    private void injectProxy(ProxySelector selector, List<ArtifactRepository> repositories) {
        if (repositories != null && selector != null) {

            effectiveRepository.setProxy(aliasedRepo.getProxy());

            effectiveRepository.setMirroredRepositories(mirroredRepos);

            effectiveRepository.setBlocked(aliasedRepo.isBlocked());

            effectiveRepositories.add(effectiveRepository);
        }

        return effectiveRepositories;
    }

    /**
     * @return whether the repository is blocked
     * @since 3.8.1
     **/
    boolean isBlocked();

    /**
     * @param blocked block the repository?
     * @since 3.8.1
     **/
    void setBlocked(boolean blocked);

    //
    // New interface methods for the repository system.
    //
    /**
     *
     * @param artifact an artifact
     * @return found artifact
     * @since 3.0-alpha-3

                    mirror.setId(repo.getId());
                    mirror.setUrl(repo.getUrl());
                    mirror.setLayout(repo.getContentType());
                    mirror.setBlocked(repo.isBlocked());
                    return mirror;
                }
            }
        }
        return null;
    }

        @Override
        public boolean isBlocked() {
            return false;
        }

        @Override
        public void setBlocked(boolean blocked) {}
    }

            this.mirroredRepositories = Collections.emptyList();
        }
    }

    @Override
    public boolean isBlocked() {
        return blocked;
    }

    @Override
    public void setBlocked(boolean blocked) {
        this.blocked = blocked;
    }

            builder.setProxy(toProxy(repo.getProxy()));
            builder.setMirroredRepositories(toRepos(repo.getMirroredRepositories()));
            builder.setBlocked(repo.isBlocked());
            result = builder.build();
        }
        return result;
    }

    public static String getLayout(ArtifactRepository repo) {
        try {

	m.respMu.Lock()
	defer m.respMu.Unlock()
	if m.closed {
		return errors.New("mux client closed")
	}
	return m.sendLocked(msg)
}

// sendLocked the message. msg.Seq and msg.MuxID will be set.
// m.respMu must be held.
func (m *muxClient) sendLocked(msg message) error {
	dst := GetByteBufferCap(msg.Msgsize())
	msg.Seq = m.SendSeq
	msg.MuxID = m.MuxID
	msg.Flags |= m.BaseFlags

PLkotlinx/coroutines/JobSupport$Finishing;->isCancelling()Z
PLkotlinx/coroutines/JobSupport$Finishing;->isCompleting()Z
PLkotlinx/coroutines/JobSupport$Finishing;->sealLocked(Ljava/lang/Throwable;)Ljava/util/List;
PLkotlinx/coroutines/JobSupport$Finishing;->setCompleting(Z)V
PLkotlinx/coroutines/JobSupport;->cancel(Ljava/util/concurrent/CancellationException;)V