}
      return textToNumericFormatV4(ipString);
    }
    return null;
  }

  @CheckForNull
  private static byte[] textToNumericFormatV4(String ipString) {
    if (IPV4_DELIMITER_MATCHER.countIn(ipString) + 1 != IPV4_PART_COUNT) {
      return null; // Wrong number of parts
    }

    byte[] bytes = new byte[IPV4_PART_COUNT];
    int start = 0;

				// return a different error in such a scenario.
				if u.Credentials.Status == auth.AccountOff {
					return nil, errAccessKeyDisabled
				}
				return nil, errInvalidAccessKeyID
			}
			cred := u.Credentials
			// Expired credentials return error.
			if cred.IsTemp() && cred.IsExpired() {
				return nil, errInvalidAccessKeyID
			}
			return []byte(cred.SecretKey), nil

      return perms;
    }

    @Override
    public PermissionCollection getPermissions(ProtectionDomain pd) {
      return perms;
    }

    @Override
    public boolean implies(ProtectionDomain pd, Permission p) {
      return perms.implies(p);
    }

    @Override
    public void refresh() {}
  }

        } catch (InvalidVersionSpecificationException e) {
            return null;
        }

        return artifactFactory.createPluginArtifact(plugin.getGroupId(), plugin.getArtifactId(), versionRange);
    }

    @Override
    public Artifact createProjectArtifact(String groupId, String artifactId, String version) {
        return createArtifact(groupId, artifactId, version, "pom");
    }

    @Override

                    logger.debug("[{}] match {}:{}", entry.getKey(), name, value);
                }
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean isAvailable() {
        if (available != null) {
            return available;
        }
        if (generatorList != null && !generatorList.isEmpty()) {

			}
			if (x >> 56) > 0 {
				p.err = ErrHeader // Integer overflow
				return 0
			}
			x = x<<8 | uint64(c)
		}
		if (x >> 63) > 0 {
			p.err = ErrHeader // Integer overflow
			return 0
		}
		if inv == 0xff {
			return ^int64(x)
		}
		return int64(x)
	}

	// Normal case is base-8 (octal) format.
	return p.parseOctal(b)
}

     * this method will return the referral path to which it maps. Otherwise
     * <code>null</code> is returned.
     * 
     * @return URL to the DFS volume
     */
    String getDfsPath ();


    /**
     * @return the transport port, if specified
     */
    int getPort ();


    /**
     * @return the original URL
     */
    URL getURL ();

	case offsetBegin > -1 && offsetEnd > -1:
		if offsetBegin > offsetEnd {
			return nil, errInvalidRange
		}
		return &HTTPRangeSpec{false, offsetBegin, offsetEnd}, nil
	case offsetBegin > -1:
		return &HTTPRangeSpec{false, offsetBegin, -1}, nil
	case offsetEnd > -1:
		if offsetEnd == 0 {
			return nil, errInvalidRange
		}
		return &HTTPRangeSpec{true, -offsetEnd, -1}, nil
	default:

	if err != nil {
		log.Errorf("Failed setting up kubernetes client with kubeconfig %s", kubeconfig)
		return nil, err
	}

	log.Debugf("istio-cni set up kubernetes client with kubeconfig %s", kubeconfig)

	// Create the client
	return kubernetes.NewForConfig(config)
}

// getK8sPodInfo returns information of a POD
func getK8sPodInfo(client kubernetes.Interface, podName, podNamespace string) (*PodInfo, error) {

    }

    @Override
    final SortedMultiset<E> multiset() {
      return multiset;
    }

    @Override
    public Iterator<E> iterator() {
      return Multisets.elementIterator(multiset().entrySet().iterator());
    }

    @Override
    public Comparator<? super E> comparator() {
      return multiset().comparator();
    }

    @Override