if (iterable instanceof List) {
      List<E> list = (List<E>) iterable;
      if (list.isEmpty()) {
        return Optional.absent();
      }
      return Optional.of(list.get(list.size() - 1));
    }
    Iterator<E> iterator = iterable.iterator();
    if (!iterator.hasNext()) {
      return Optional.absent();
    }

    /*

    TFE_Executor*, TF_Status* status);

// When an error happens, any pending operations are discarded, and newly issued
// ops return an error. This call clears the error state and re-enables
// execution of newly issued ops.
//
// Note that outputs of discarded ops remain in a corrupt state and should not
// be used for future calls.
// TODO(agarwal): mark the affected handles and raise errors if they are used.

        return set2.containsAll(set1);
      }

      @Override
      public boolean contains(@Nullable Object element) {
        return set1.contains(element) && !set2.contains(element);
      }

      @Override
      int minSize() {
        return max(minSize(set1) - maxSize(set2), 0);
      }

      @Override
      int maxSize() {
        return maxSize(set1);
      }

			apiErr.Description = fmt.Sprintf("The authorization header is malformed; the region is wrong; expecting '%s'.", region)
			return apiErr
		}
	}
	return apiErr
}

func (e errorCodeMap) ToAPIErr(errCode APIErrorCode) APIError {
	return e.ToAPIErrWithErr(errCode, nil)
}

// error code to APIError structure, these fields carry respective
// descriptions for all the error responses.

      if (c.isEmpty()) {
        return defaultValue;
      } else if (iterable instanceof List) {
        return getLastInNonemptyList((List<? extends T>) iterable);
      } else if (iterable instanceof SortedSet) {
        return ((SortedSet<? extends T>) iterable).last();
      }
    }

    return Iterators.getLast(iterable.iterator(), defaultValue);
  }

                return e;
              }
            }
            return endOfData();
          }
        };
      }

      @Override
      public Stream<E> stream() {
        return Stream.concat(set1.stream(), set2.stream().filter((E e) -> !set1.contains(e)));
      }

      @Override
      public Stream<E> parallelStream() {
        return stream().parallel();
      }

     * element is retained).
     *
     * @param element the element to add
     * @return this {@code Builder} object
     * @throws NullPointerException if {@code element} is null
     */
    @CanIgnoreReturnValue
    @Override
    public Builder<E> add(E element) {
      super.add(element);
      return this;
    }

    /**

      if (c.isEmpty()) {
        return defaultValue;
      } else if (iterable instanceof List) {
        return getLastInNonemptyList((List<? extends T>) iterable);
      } else if (iterable instanceof SortedSet) {
        return ((SortedSet<? extends T>) iterable).last();
      }
    }

    return Iterators.getLast(iterable.iterator(), defaultValue);
  }

        case "source_titles":
            return buildSourceTitlesContent(msg, summaryMaxChars);
        case "source_titles_and_urls":
            return buildSourceTitlesAndUrlsContent(msg);
        case "truncated":
            return buildTruncatedContent(msg, assistantMaxChars);
        case "none":
            return null;
        default:
            return msg.getContent();
        }
    }

    /**

		}
		if osIsPermission(err) {
			return errDiskAccessDenied
		} else if isSysErrIO(err) {
			return errFaultyDisk
		}
		return err
	}

	// Stat succeeds we return errVolumeExists.
	return errVolumeExists
}

// ListVols - list volumes.
func (s *xlStorage) ListVols(ctx context.Context) (volsInfo []VolInfo, err error) {
	return listVols(ctx, s.drivePath)
}