return 0x07;
        }

        public int retval;
        public rpc.policy_handle handle;
        public int access_mask;
        public rpc.sid_t sid;
        public rpc.policy_handle domain_handle;


        public SamrOpenDomain ( rpc.policy_handle handle, int access_mask, rpc.sid_t sid, rpc.policy_handle domain_handle ) {
            this.handle = handle;

		Method: http.MethodPost,
		URL:    u,
	}
	if !guessIsRPCReq(r) {
		t.Fatal("Test shouldn't fail for a possible net/rpc request.")
	}
	r = &http.Request{
		Proto:  "HTTP/1.1",
		Method: http.MethodGet,
		URL:    u,
	}
	if !guessIsRPCReq(r) {
		t.Fatal("Test shouldn't fail for a possible net/rpc request.")
	}
	r = &http.Request{
		Proto:  "HTTP/1.1",
		Method: http.MethodGet,
		URL:    &url.URL{Path: grid.RoutePath},

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

package jcifs.smb1.dcerpc.msrpc;

import jcifs.smb1.dcerpc.rpc;

public class MsrpcSamrCloseHandle extends samr.SamrCloseHandle {

    public MsrpcSamrCloseHandle(rpc.policy_handle policyHandle) {
        super(policyHandle);
        ptype = 0;
        flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

	"cmd/internal/obj/wasm"
	"cmd/internal/obj/x86"
	"fmt"
	"strings"
)

// Pseudo-registers whose names are the constant name without the leading R.
const (
	RFP = -(iota + 1)
	RSB
	RSP
	RPC
)

// Arch wraps the link architecture object with more architecture-specific information.
type Arch struct {
	*obj.LinkArch
	// Map of instruction names to enumeration.
	Instructions map[string]obj.As

   *     be unique to the built instance of the ThreadFactory and will be assigned sequentially. For
   *     example, {@code "rpc-pool-%d"} will generate thread names like {@code "rpc-pool-0"}, {@code
   *     "rpc-pool-1"}, {@code "rpc-pool-2"}, etc.
   * @return this for the builder pattern
   */
  @CanIgnoreReturnValue
  public ThreadFactoryBuilder setNameFormat(String nameFormat) {

 */

package jcifs.smb1.dcerpc;

public class UnicodeString extends rpc.unicode_string {

    boolean zterm;

    public UnicodeString(boolean zterm) {
        this.zterm = zterm;
    }
    public UnicodeString(rpc.unicode_string rus, boolean zterm) {
        this.length = rus.length;
        this.maximum_length = rus.maximum_length;

		}
		entries.truncate(0)
		go func() {
			rpc := globalNotificationSys.restClientFromHash(pathJoin(o.Bucket, o.Prefix))
			if rpc != nil {
				ctx, cancel := context.WithTimeout(GlobalContext, 5*time.Second)
				defer cancel()
				c, err := rpc.GetMetacacheListing(ctx, *o)
				if err == nil {
					c.error = "no longer used"
					c.status = scanStateError
					rpc.UpdateMetacacheListing(ctx, *c)
				}
			}
		}()

 */

package jcifs.dcerpc.msrpc;


import jcifs.dcerpc.rpc;


@SuppressWarnings ( "javadoc" )
public class MsrpcSamrOpenDomain extends samr.SamrOpenDomain {

    public MsrpcSamrOpenDomain ( SamrPolicyHandle handle, int access, rpc.sid_t sid, SamrDomainHandle domainHandle ) {
        super(handle, access, sid, domainHandle);
        this.ptype = 0;

		i++
	}
}

// updateMetacacheListing will update the metacache listing.
func (o *listPathOptions) updateMetacacheListing(m metacache, rpc *peerRESTClient) (metacache, error) {
	if rpc == nil {
		return localMetacacheMgr.updateCacheEntry(m)
	}
	return rpc.UpdateMetacacheListing(context.Background(), m)
}

func getMetacacheBlockInfo(fi FileInfo, block int) (*metacacheBlock, error) {
	var tmp metacacheBlock

        if ( this.result != 0 )
            return new DcerpcException(this.result);
        return null;
    }


    void encode_header ( NdrBuffer buf ) {
        buf.enc_ndr_small(5); /* RPC version */
        buf.enc_ndr_small(0); /* minor version */
        buf.enc_ndr_small(this.ptype);
        buf.enc_ndr_small(this.flags);
        buf.enc_ndr_long(0x00000010); /* Little-endian / ASCII / IEEE */