}
	return ift, nil
}

func linkFlags(rawFlags int) Flags {
	var f Flags
	if rawFlags&syscall.IFF_UP != 0 {
		f |= FlagUp
	}
	if rawFlags&syscall.IFF_RUNNING != 0 {
		f |= FlagRunning
	}
	if rawFlags&syscall.IFF_BROADCAST != 0 {
		f |= FlagBroadcast
	}
	if rawFlags&syscall.IFF_LOOPBACK != 0 {
		f |= FlagLoopback
	}
	if rawFlags&syscall.IFF_POINTOPOINT != 0 {
		f |= FlagPointToPoint
	}

			}
		}
	}
	return ift[:n], nil
}

func linkFlags(rawFlags int) Flags {
	var f Flags
	if rawFlags&syscall.IFF_UP != 0 {
		f |= FlagUp
	}
	if rawFlags&syscall.IFF_RUNNING != 0 {
		f |= FlagRunning
	}
	if rawFlags&syscall.IFF_BROADCAST != 0 {
		f |= FlagBroadcast
	}
	if rawFlags&syscall.IFF_LOOPBACK != 0 {
		f |= FlagLoopback
	}
	if rawFlags&syscall.IFF_POINTOPOINT != 0 {
		f |= FlagPointToPoint
	}

	}

	return ift, nil
}

func linkFlags(rawFlags int32) Flags {
	var f Flags
	if rawFlags&syscall.IFF_UP != 0 {
		f |= FlagUp
	}
	if rawFlags&syscall.IFF_RUNNING != 0 {
		f |= FlagRunning
	}
	if rawFlags&syscall.IFF_BROADCAST != 0 {
		f |= FlagBroadcast
	}
	if rawFlags&syscall.IFF_LOOPBACK != 0 {
		f |= FlagLoopback
	}
	if rawFlags&syscall.IFF_POINTOPOINT != 0 {
		f |= FlagPointToPoint
	}

		}
	}
	return ifi
}

func linkFlags(rawFlags uint32) Flags {
	var f Flags
	if rawFlags&syscall.IFF_UP != 0 {
		f |= FlagUp
	}
	if rawFlags&syscall.IFF_RUNNING != 0 {
		f |= FlagRunning
	}
	if rawFlags&syscall.IFF_BROADCAST != 0 {
		f |= FlagBroadcast
	}
	if rawFlags&syscall.IFF_LOOPBACK != 0 {
		f |= FlagLoopback
	}
	if rawFlags&syscall.IFF_POINTOPOINT != 0 {
		f |= FlagPointToPoint
	}

    public <T> Class<T> getRawClass() {
        return (Class<T>) rawClass;
    }

    /**
     * 原型となるクラスを設定します。
     *
     * @param rawClass
     *            原型となるクラス。{@literal null}であってはいけません
     */
    public void setRawClass(final Class<?> rawClass) {
        assertArgumentNotNull("rawClass", rawClass);

        this.rawClass = rawClass;
    }

    @Override

        // Remove strong internal circular ref
        (schema.type.rawClass.classLoader as GroovyClassLoader).clearCache()

        // Remove soft references (dependent on Groovy internals)
        ModelStoreTestUtils.removeClassFromGlobalClassSet(schema.type.rawClass)

        // Remove soft references
        Introspector.flushFromCaches(schema.type.rawClass)
    }

            Class<?> rawClass = type.getRawClass();
            if (rawClass.equals(Object.class) || rawClass.equals(GroovyObject.class)) {
                continue;
            }
            // Do not reprocess
            if (!seenTypes.add(type)) {
                continue;
            }

            Class<?> superclass = rawClass.getSuperclass();
            if (superclass != null) {

        !extendsString.isClass()
        !superString.isClass()
        !objects.isClass()
        !anything.isClass()

        extendsString.rawClass == String
        superString.rawClass == Object
        objects.rawClass == Object
        anything.rawClass == Object

        extendsString.upperBound == ModelType.of(String)
        extendsString.lowerBound == null

        superString.upperBound == null

        return type.isClass()
            && !rawClass().isArray();
    }

    /**
     * Queries whether this object represents a synthetic type as defined by {@link Class#isSynthetic()}.
     *
     * @return true if this object represents a synthetic type.
     */
    public boolean isSynthetic() {
        return rawClass().isSynthetic();
    }

    /**

    public <T> void extract(ModelSchemaExtractionContext<T> extractionContext) {
        ModelType<T> type = extractionContext.getType();
        Class<? super T> rawClass = type.getRawClass();
        List<ModelType<?>> typeVariables = type.getTypeVariables();
        if (TYPES.contains(rawClass)) {
            if (typeVariables.size() > 0 && ScalarTypes.isScalarType(typeVariables.get(0))) {