public static <E extends @Nullable Object> FluentIterable<E> from(FluentIterable<E> iterable) {
    return checkNotNull(iterable);
  }

  /**
   * Returns a fluent iterable that combines two iterables. The returned iterable has an iterator
   * that traverses the elements in {@code a}, followed by the elements in {@code b}. The source
   * iterators are not polled until necessary.
   *

  public static <E extends @Nullable Object> FluentIterable<E> from(FluentIterable<E> iterable) {
    return checkNotNull(iterable);
  }

  /**
   * Returns a fluent iterable that combines two iterables. The returned iterable has an iterator
   * that traverses the elements in {@code a}, followed by the elements in {@code b}. The source
   * iterators are not polled until necessary.
   *

   */
  // TODO(user): Evaluate whether it makes sense to always piggyback the computation of a
  // HashCode on an existing OutputStream, compared to creating a separate OutputStream that could
  // be (optionally) be combined with another if needed (with something like
  // MultiplexingOutputStream).
  public HashingOutputStream(HashFunction hashFunction, OutputStream out) {
    super(checkNotNull(out));

            }
        }

        return dr;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.dfs.DfsReferralDataInternal#combine(jcifs.DfsReferralData)
     */
    @Override
    public DfsReferralDataInternal combine(final DfsReferralData n) {
        final DfsReferralDataImpl dr = new DfsReferralDataImpl();
        dr.server = n.getServer();
        dr.share = n.getShare();

  val survey = CipherSuiteSurvey(clients = clients, ianaSuites = ianaSuitesNew, orderBy = orderBy)

  survey.printGoogleSheet()
}

fun rest(clients: List<Client>): List<SuiteId> {
  // combine all ciphers to get these near the top
  return clients.flatMap { it.enabled }

        byte[] badSid = new byte[10];
        badSid[1] = 101; // sub_authority_count > 100
        assertThrows(RuntimeCIFSException.class, () -> new SID(badSid, 0));
    }

    /**
     * Test constructor that combines a domain SID and an RID.
     *
     * @throws SmbException if the SID string is invalid
     */
    @Test
    void testDomainSidAndRidConstructor() throws SmbException {

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package replication

import (
	"encoding/xml"
)

// And - a tag to combine a prefix and multiple tags for replication configuration rule.
type And struct {
	XMLName xml.Name `xml:"And" json:"And"`
	Prefix  string   `xml:"Prefix,omitempty" json:"Prefix,omitempty"`

# GraphQL { #graphql }

As **FastAPI** is based on the **ASGI** standard, it's very easy to integrate any **GraphQL** library also compatible with ASGI.

You can combine normal FastAPI *path operations* with GraphQL on the same application.

/// tip

**GraphQL** solves some very specific use cases.

It has **advantages** and **disadvantages** when compared to common **web APIs**.

            assertEquals(flag, response.getCapabilities());
        }
    }

    @Test
    @DisplayName("Should handle combined capability flags")
    void testCombinedCapabilityFlags() throws SMBProtocolDecodingException {
        // Given - all capabilities combined
        int allCapabilities = Smb2TreeConnectResponse.SMB2_SHARE_CAP_DFS | Smb2TreeConnectResponse.SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY

            SID dom = new SID("S-1-5-21");
            SID rel = new SID("S-1-2-200-300"); // two subauthorities appended

            // Act
            SID combined = new SID(dom, rel);

            // Assert
            assertEquals("S-1-5-21-200-300", combined.toString());
        }

        @Test
        @DisplayName("Constructor from sid_t with decrementAuthority drops last subauthority")