return solutions;
    }

    @Nullable
    @Override
    public String getDetails() {
        return details;
    }

    @Override
    public List<ProblemLocation> getLocations() {
        return problemLocations;
    }

    @Nullable
    @Override
    public RuntimeException getException() {
        return exception;
    }

    @Override

        return details;
    }

    @Nullable
    @Override
    public InternalContextualLabel getContextualLabel() {
        return contextualLabel;
    }

    @Override
    public List<InternalLocation> getLocations() {
        return locations;
    }

    @Override
    public InternalProblemDefinition getDefinition() {
        return definition;
    }


    @Override

        DistributionManagement distMgmt = model.getDistributionManagement();
        if (distMgmt != null) {
            Relocation relocation = distMgmt.getRelocation();
            if (relocation != null) {
                Artifact result = new RelocatedArtifact(
                        artifactDescriptorResult.getRequest().getArtifact(),
                        relocation.getGroupId(),

        return contextualLabel;
    }

    @Override
    public Details getDetails() {
        return details;
    }

    @Override
    public List<Location> getLocations() {
        return locations;
    }

    @Override
    public List<Solution> getSolutions() {
        return solutions;
    }

    @Nullable
    @Override
    public FailureContainer getFailure() {

          LocationExtractor(loc.getCallee()).Extract(error_data);
          LocationExtractor(loc.getCaller()).Extract(error_data);
        })
        .Case<FusedLoc>([&](FusedLoc loc) {
          auto locations = loc.getLocations();
          size_t num_locs = locations.size();
          // Skip the first location if it stores information for propagating
          // op_type metadata.
          if (num_locs > 0) {

        if (model.getDistributionManagement() != null
                && model.getDistributionManagement().getRelocation() != null) {
            // keep relocation only
            builder.distributionManagement(DistributionManagement.newBuilder()
                    .relocation(model.getDistributionManagement().getRelocation())
                    .build());
        }
        // only keep repositories other than 'central'

      return quant_unit;
    }
  } else if (isa<FusedLoc>(loc)) {
    // If the op is rewritten, FusedLoc can be created.
    for (Location child_loc : mlir::cast<FusedLoc>(loc).getLocations()) {
      std::optional<QuantizationUnitLoc::QuantizationUnit> found_unit =
          FindQuantizationUnitFromLoc(child_loc);
      if (found_unit.has_value()) return found_unit;
    }

            }
        }
        result
    }

    long getOperationId() {
        operationId
    }

    <T> T oneLocation(Class<T> type) {
        def locations = getLocations()
        assert locations.size() == 1
        assert type.isInstance(locations[0])
        locations[0] as T
    }

    @Override
    ReceivedProblemDefinition getDefinition() {
        definition
    }

                    return null;
                }
                result.addException(e);
                throw new ArtifactDescriptorException(result);
            }

            Artifact relocatedArtifact = getRelocation(session, result, model);
            if (relocatedArtifact != null) {
                if (withinSameGav(relocatedArtifact, a)) {
                    result.setArtifact(relocatedArtifact);

                return new DefaultInternalProblemContextDetails(
                    basicDetails.getAdditionalData(),
                    basicDetails.getDetails(),
                    basicDetails.getLocations(),
                    basicDetails.getSolutions(),
                    basicDetails.getFailure(),
                    basicDetails.getContextualLabel()
                );
            } else {