return size, nil
		}
		var actualSize int64
		for _, part := range o.Parts {
			actualSize += part.ActualSize
		}
		if (actualSize == 0) && (actualSize != o.Size) {
			return -1, errInvalidDecompressedSize
		}
		return actualSize, nil
	}
	if _, ok := crypto.IsEncrypted(o.UserDefined); ok {
		sizeStr := o.UserDefined[ReservedMetadataPrefix+"actual-size"]
		if sizeStr != "" {
			size, err := strconv.ParseInt(sizeStr, 10, 64)

    }


    protected static final int size8 ( int size ) {
        return size8(size, 0);
    }


    protected static final int size8 ( int size, int align ) {

        int rem = size % 8 - align;
        if ( rem == 0 ) {
            return size;
        }
        if ( rem < 0 ) {
            rem = 8 + rem;
        }
        return size + 8 - rem;
    }


    /**

                }
                else {
                    list.add(s);
                }
            }

            if ( list.size() > 0 ) {
                SID[] resolved = list.toArray(new SID[list.size()]);
                resolveSids0(authorityServerName, tc, resolved);
                for ( si = 0; si < resolved.length; si++ ) {

        if (codeSource != null) {
            try {
                classpath.add(new File(codeSource.getLocation().toURI()));
            } catch (URISyntaxException e) {
                // silent
            }
        }
    }

    private List<JApiCmpWorkerAction.Archive> inferArchives(FileCollection fc) {
        if (fc instanceof Configuration) {

        this.closeFlags = flags;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override
    public int size () {
        return size8(Smb2Constants.SMB2_HEADER_LENGTH + 24);
    }


    /**
     * {@inheritDoc}
     *

                for ( int _i = 0; _i < _bufferl; _i++ ) {
                    this.buffer[ _i ] = (short) _src.dec_ndr_short();
                }
            }
        }
    }

    public static class sid_t extends NdrObject {

        public byte revision;
        public byte sub_authority_count;
        public byte[] identifier_authority;
        public int[] sub_authority;


        @Override

    checkNotNull(other);
    int size = size();

    if (other.length < size) {
      Object[] internal = internalArray();
      if (internal != null) {
        return Platform.copy(internal, internalArrayStart(), internalArrayEnd(), other);
      }
      other = ObjectArrays.newArray(other, size);
    } else if (other.length > size) {
      other[size] = null;
    }
    copyIntoArray(other, 0);

  // Create two vectors with different lengths
  std::vector<float> size_two_value{1., 2.};
  std::vector<float> size_three_value{1., 2., 3.};
  TensorHandlePtr size_two(
      VectorFloatTensorHandle(size_two_value, status.get()));
  ASSERT_EQ(TF_GetCode(status.get()), TF_OK) << TF_Message(status.get());
  TensorHandlePtr size_three(

				writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMissingContentLength), r.URL)
				return
			}
			size, err = strconv.ParseInt(sizeStr[0], 10, 64)
			if err != nil {
				writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
				return
			}
		}
	}

	if size == -1 {
		writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMissingContentLength), r.URL)
		return
	}

 * toDisplayString: WNET\Domain Admins
 *         getType: 2
 *     getTypeText: Domain group
 *   getDomainName: WNET
 *  getAccountName: Domain Admins
 * </pre>
 */

public class SID extends rpc.sid_t {

    public static final int SID_TYPE_USE_NONE = lsarpc.SID_NAME_USE_NONE;
    public static final int SID_TYPE_USER    = lsarpc.SID_NAME_USER;
    public static final int SID_TYPE_DOM_GRP = lsarpc.SID_NAME_DOM_GRP;