59: 		TYPE *Stream;

98: 		TYPE *Stream;

147: 		TYPE *Stream;

601: 		TYPE *Stream;

62: 		BIT_LE_R() { Stream = NULL; }

63: 		BIT_LE_R(TYPE *s) { Stream = s; Reminder = Offset = 0; }

64: 		BIT_LE_R(TYPE &s) { Stream = &s; Reminder = Offset = 0; }

73: 				if (Offset == 0) Reminder = Stream->R8b();

101: 		BIT_LE_W() { Stream = NULL; }

102: 		BIT_LE_W(TYPE *s) { Stream = s; Reminder = Offset = 0; }

103: 		BIT_LE_W(TYPE &s) { Stream = &s; Reminder = Offset = 0; }

110: 				Stream->W8b(Reminder);

128: 					Stream->W8b(Reminder);

149: 		BYTE_NT() { Stream = NULL; }

150: 		BYTE_NT(TYPE *s) { Stream = s; }

151: 		BYTE_NT(TYPE &s) { Stream = &s; }

156: 			return Stream->Position();

161: 			Stream->SetPosition(Pos);

167: 			Stream->ReadData(Buffer, Count);

172: 			return Stream->R8b();

178: 			Stream->WriteData(Buffer, Count);

183: 			Stream->W8b(val);

193: 			val = Stream->R8b(); return *this;

198: 			val = Stream->R8b(); return *this;

203: 			Stream->ReadData(pval, n); return *this;

208: 			Stream->ReadData(pval, n); return *this;

214: 			val = Stream->R16b(); return *this;

219: 			val = Stream->R16b(); return *this;

224: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;

229: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;

235: 			val = Stream->R32b(); return *this;

240: 			val = Stream->R32b(); return *this;

245: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;

250: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;

256: 			val = Stream->R64b(); return *this;

261: 			val = Stream->R64b(); return *this;

266: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;

271: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;

277: 			Stream->ReadData(&val, sizeof(val)); return *this;

282: 			Stream->ReadData(&val, sizeof(val)); return *this;

287: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;

292: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;

302: 			Stream->W8b(val); return *this;

307: 			Stream->W8b(val); return *this;

312: 			Stream->WriteData(pval, n); return *this;

317: 			Stream->WriteData(pval, n); return *this;

323: 			Stream->W16b(val); return *this;

328: 			Stream->W16b(val); return *this;

333: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

338: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

344: 			Stream->W32b(val); return *this;

349: 			Stream->W32b(val); return *this;

354: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

359: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

365: 			Stream->W64b(val); return *this;

370: 			Stream->W64b(val); return *this;

375: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

380: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

386: 			Stream->WriteData(&val, sizeof(val)); return *this;

391: 			Stream->WriteData(&val, sizeof(val)); return *this;

396: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

401: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

456: 				Stream->WriteData(Buffer, sizeof(*pval)*L); \

603: 		BYTE_LE() { Stream = NULL; }

604: 		BYTE_LE(TYPE *s) { Stream = s; }

605: 		BYTE_LE(TYPE &s) { Stream = &s; }

610: 			return Stream->Position();

615: 			Stream->SetPosition(Pos);

621: 			Stream->ReadData(Buffer, Count);

626: 			return Stream->R8b();

632: 			Stream->WriteData(Buffer, Count);

637: 			Stream->W8b(val);

647: 			val = Stream->R8b(); return *this;

652: 			val = Stream->R8b(); return *this;

657: 			Stream->ReadData(pval, n); return *this;

662: 			Stream->ReadData(pval, n); return *this;

668: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R16b()); return *this;

673: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R16b()); return *this;

678: 			Stream->ReadData(pval, sizeof(*pval)*n);

685: 			Stream->ReadData(pval, sizeof(*pval)*n);

693: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R32b()); return *this;

698: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R32b()); return *this;

703: 			Stream->ReadData(pval, sizeof(*pval)*n);

710: 			Stream->ReadData(pval, sizeof(*pval)*n);

718: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R64b()); return *this;

723: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R64b()); return *this;

728: 			Stream->ReadData(pval, sizeof(*pval)*n);

735: 			Stream->ReadData(pval, sizeof(*pval)*n);

743: 			Stream->ReadData(&val, sizeof(val));

750: 			Stream->ReadData(&val, sizeof(val));

757: 			Stream->ReadData(pval, sizeof(*pval)*n);

764: 			Stream->ReadData(pval, sizeof(*pval)*n);

776: 			Stream->W8b(val); return *this;

781: 			Stream->W8b(val); return *this;

786: 			Stream->WriteData(pval, n); return *this;

791: 			Stream->WriteData(pval, n); return *this;

797: 			Stream->W16b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;

802: 			Stream->W16b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;

808: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

817: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

826: 			Stream->W32b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;

831: 			Stream->W32b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;

837: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

846: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

855: 			Stream->W64b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;

860: 			Stream->W64b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;

866: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

875: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

885: 			Stream->WriteData(&val, sizeof(val));

892: 			Stream->WriteData(&val, sizeof(val));

899: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

908: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;

922: 			B = Stream->R8b(); rv = B & 0x7F;			// 1

924: 			B = Stream->R8b(); rv |= (B & 0x7F) << 7;	// 2

926: 			B = Stream->R8b(); rv |= (B & 0x7F) << 14;	// 3

933: 			B = Stream->R8b(); rv = B & 0x7F;			// 1

935: 			B = Stream->R8b(); rv |= (B & 0x7F) << 7;	// 2

937: 			B = Stream->R8b(); rv |= (B & 0x7F) << 14;	// 3

939: 			B = Stream->R8b(); rv |= (B & 0x7F) << 21;	// 4

941: 			B = Stream->R8b(); rv |= (B & 0x7F) << 28;	// 5

948: 			B = Stream->R8b(); rv = B & 0x7F;					// 1

950: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 7;	// 2

952: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 14;	// 3

954: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 21;	// 4

956: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 28;	// 5

958: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 35;	// 6

960: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 42;	// 7

962: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 49;	// 8

964: 			B = Stream->R8b(); rv |= C_UInt64(B) << 56;			// 9

973: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

975: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

976: 			Stream->W8b(val);				// 3

983: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

985: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

987: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

989: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

990: 			Stream->W8b(val);				// 5

997: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

999: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

1001: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

1003: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

1005: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

1007: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

1009: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

1011: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }

1012: 			Stream->W8b(val);				// 9

1024: 			Stream->ReadData(&rv[0], L);

1031: 			BIT_LE_R<TYPE> RBit(Stream);

1055: 			Stream->WriteData(&(val[0]), val.size());

1062: 			BIT_LE_W<TYPE> WBit(Stream);

1093: 			Stream->ReadData(&v, GDS_POS_SIZE);

1095: 			v |= Stream->R8b();

1096: 			v |= (C_UInt64)Stream->R8b() << 8;

1097: 			v |= (C_UInt64)Stream->R8b() << 16;

1098: 			v |= (C_UInt64)Stream->R8b() << 24;

1099: 			v |= (C_UInt64)Stream->R8b() << 32;

1100: 			v |= (C_UInt64)Stream->R8b() << 40;

1110: 			Stream->WriteData(&v, GDS_POS_SIZE);

1112: 			Stream->W8b(v); v >>= 8;

1113: 			Stream->W8b(v); v >>= 8;

1114: 			Stream->W8b(v); v >>= 8;

1115: 			Stream->W8b(v); v >>= 8;

1116: 			Stream->W8b(v); v >>= 8;

1117: 			Stream->W8b(v);

54: 	/** \tparam TYPE    it could be CdStream, CdBufStream or CdAllocator

93: 	/** \tparam TYPE    it could be CdStream, CdBufStream or CdAllocator

143: 	/** \tparam TYPE    it could be CdStream, CdBufStream or CdAllocator

597: 	/** \tparam TYPE    it could be CdStream, CdBufStream or CdAllocator

101: inline FILE*& Output2FILE::Stream()

97:     static FILE*& Stream();

109:     FILE* pStream = Stream();

137:     else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \

103:     static FILE* pStream = stderr;

104:     return pStream;

110:     if (!pStream)

112:     fprintf(pStream, "%s", msg.c_str());

113:     fflush(pStream);

108: inline FILE*& Output2FILE::Stream()

104:     static FILE*& Stream();

116:     FILE* pStream = Stream();

144:     else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \

110:     static FILE* pStream = stderr;

111:     return pStream;

117:     if (!pStream)

119:     fprintf(pStream, "%s", msg.c_str());

120:     fflush(pStream);

31: class Stream1dStringDataset {

39:     Stream1dStringDataset(const H5::DataSet* ptr, hsize_t length, hsize_t buffer_size) : 

63:     Stream1dStringDataset(const H5::DataSet* ptr, hsize_t buffer_size) : 

17:  * @file Stream1dStringDataset.hpp

18:  * @brief Stream a numeric 1D HDF5 dataset into memory.

26:  * @brief Stream a 1D HDF5 string dataset into memory.

64:         Stream1dStringDataset(ptr, get_1d_length(ptr->getSpace(), false), buffer_size) 

31: class Stream1dNumericDataset {

39:     Stream1dNumericDataset(const H5::DataSet* ptr, hsize_t length, hsize_t buffer_size) : 

54:     Stream1dNumericDataset(const H5::DataSet* ptr, hsize_t buffer_size) : 

15:  * @file Stream1dNumericDataset.hpp

16:  * @brief Stream a numeric 1D HDF5 dataset into memory.

24:  * @brief Stream a numeric 1D HDF5 dataset into memory.

55:         Stream1dNumericDataset(ptr, get_1d_length(ptr->getSpace(), false), buffer_size) 

1: .Stream <- setRefClass("Stream", contains = "Consumer")

3: .Stream$methods(

10: setMethod(length, "Stream",

22: setMethod("[[", c("Stream", "numeric"),

307: RngStream RngStream_CreateStream (const char name[])

337: void RngStream_DeleteStream (RngStream g)

348: void RngStream_ResetStartStream (RngStream g)

357: void RngStream_ResetNextSubstream (RngStream g)

368: void RngStream_ResetStartSubstream (RngStream g)

377: int RngStream_SetPackageSeed (unsigned long seed[6])

389: int RngStream_SetSeed (RngStream g, unsigned long seed[6])

401: void RngStream_AdvanceState (RngStream g, long e, long c)

432: void RngStream_GetState (RngStream g, unsigned long seed[6])

441: void RngStream_WriteState (RngStream g)

459: void RngStream_WriteStateFull (RngStream g)

491: void RngStream_IncreasedPrecis (RngStream g, int incp)

498: void RngStream_SetAntithetic (RngStream g, int a)

505: double RngStream_RandU01 (RngStream g)

515: int RngStream_RandInt (RngStream g, int i, int j)

3:  * File:           RngStream.c for multiple streams of Random Numbers

14: #include "RngStream.h"

213: static double U01 (RngStream g)

246: static double U01d (RngStream g)

310:    RngStream g;

313:    g = (RngStream) malloc (sizeof (struct RngStream_InfoState));

315:       Rprintf ("RngStream_CreateStream: No more memory\n\n");

316:       error("RngStream allocation failed. Exiting.");

464:    Rprintf ("The RngStream");

517:    return i + (int) ((j - i + 1.0) * RngStream_RandU01 (g));

81: plotVelocityStream <- function(sce, embedded, use.dimred = 1,

3: #' Plot velocities embedded into low-dimensional space as a stream plot. Stream

48: #'   Streamlines are computed by simple integration with a forward Euler method,

70: #' plotVelocityStream(out, em)

71: #' plotVelocityStream(out, em, color.streamlines = TRUE)

112:         stop("'plotVelocityStream' requires the package 'ggplot2'.")

19: typedef struct RngStream_InfoState * RngStream;

21: struct RngStream_InfoState {

2:    RngStream.h for ANSI C

29: int RngStream_SetPackageSeed (unsigned long seed[6]);

32: RngStream RngStream_CreateStream (const char name[]);

35: void RngStream_DeleteStream (RngStream g);

38: void RngStream_ResetStartStream (RngStream g);

41: void RngStream_ResetStartSubstream (RngStream g);

44: void RngStream_ResetNextSubstream (RngStream g);

47: void RngStream_SetAntithetic (RngStream g, int a);

50: void RngStream_IncreasedPrecis (RngStream g, int incp);

53: int RngStream_SetSeed (RngStream g, unsigned long seed[6]);

56: void RngStream_AdvanceState (RngStream g, long e, long c);

59: void RngStream_GetState (RngStream g, unsigned long seed[6]);

62: void RngStream_WriteState (RngStream g);

65: void RngStream_WriteStateFull (RngStream g);

68: double RngStream_RandU01 (RngStream g);

71: int RngStream_RandInt (RngStream g, int i, int j);

417: PWIZ_API_DECL BinaryIndexStream::BinaryIndexStream(shared_ptr<iostream> isPtr) : impl_(new Impl(isPtr)) {}

259:     typedef stream_vector_const_iterator<Entry, EntryReader> IndexStreamIterator;

270:             throw runtime_error("[BinaryIndexStream::ctor] Stream is null");

25: #include "BinaryIndexStream.hpp"

215: class BinaryIndexStream::Impl

313:             throw runtime_error("[BinaryIndexStream::create] creating index with huge ids (" + longestIdEntryItr->id + ") probably means ids are not be...(23 bytes skipped)...

418: PWIZ_API_DECL void BinaryIndexStream::create(vector<Entry>& entries) {impl_->create(entries);}

419: PWIZ_API_DECL size_t BinaryIndexStream::size() const {return impl_->size();}

420: PWIZ_API_DECL Index::EntryPtr BinaryIndexStream::find(const string& id) const {return impl_->find(id);}

421: PWIZ_API_DECL Index::EntryPtr BinaryIndexStream::find(size_t index) const {return impl_->find(index);}

379:             IndexStreamIterator itr(isPtr_, entrySize_, entryReader_, indexBegin, indexEnd);

380:             itr = lower_bound(itr, IndexStreamIterator(), *entryPtr, EntryIdLessThan());

383:             if (itr == IndexStreamIterator())

80: LogStream::LogStream(int verbosity, std::ostream *out, bool profile) :

86: LogStream::~LogStream() {

91: void LogStream::setStream(std::ostream *out) { 

96: void LogStream::unsetStream(std::ostream *out) { 

21:  * @file   LogStream.cpp

28: #include "util/LogStream.h"

107: void LogStream::message(int verbosity, const std::string &log, bool delimiter) {

133: void LogStream::progressBegin(int verbosity, const std::string &msg, int total) {

162: void LogStream::progressStep(int verbosity) {

184: void LogStream::progressEnd(int verbosity, const std::string &msg) {

232: void LogStream::setBaseVerbosity(int verbosity) { // do notthing

316: std::string LogStream::profileString() {

10: RCPtr<istream> InputStream(string const & filename) {

30: RCPtr<ostream> OutputStream(string const & filename) {

2: #define __StreamFromFileNameGenerator_hpp

1: #ifndef __StreamFromFileNameGenerator_hpp

34: InFileStream::InFileStream() :

41: InFileStream::InFileStream(const char *filename) :

7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line

28: #include "InFileStream.h"

38:     //Rcpp::Rcout << "InFileStream() constructor 1" << endl;

44:     //Rcpp::Rcout << "InFileStream(f) constructor 2" << endl;

49: //- InFileStream::InFileStream(const InFileStream &copy) :

52: //-     Rcpp::Rcout << "InFileStream() constructor 3" << endl;

56: void InFileStream::open(const char *filename)

67: void InFileStream::close()

74: std::istream& InFileStream::getline(char *s, streamsize n)

80: std::istream& InFileStream::getline(char *s, streamsize n, char delim)

93:  * 09-02-07,Nigel Brown(EMBL): moved member into new InFileStream subclassed

95:  * that uses InFileStream in place of std::ifstream. Replaced if/then/else

98: char InFileStream::findDelimiter()

34: InFileStream::InFileStream() :

41: InFileStream::InFileStream(const char *filename) :

7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line

28: #include "InFileStream.h"

38:     //cout << "InFileStream() constructor 1" << endl;

44:     //cout << "InFileStream(f) constructor 2" << endl;

49: //- InFileStream::InFileStream(const InFileStream &copy) :

52: //-     cout << "InFileStream() constructor 3" << endl;

56: void InFileStream::open(const char *filename) 

67: void InFileStream::close() 

74: std::istream& InFileStream::getline(char *s, streamsize n) 

80: std::istream& InFileStream::getline(char *s, streamsize n, char delim) 

93:  * 09-02-07,Nigel Brown(EMBL): moved member into new InFileStream subclassed

95:  * that uses InFileStream in place of std::ifstream. Replaced if/then/else

98: char InFileStream::findDelimiter()

22: class InFileStream : public std::ifstream

7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line

25:     InFileStream();

26:     InFileStream(const char *filename);

27:     //- InFileStream(const InFileStream &copy);

45:     InFileStream(const InFileStream &copy);

22: class InFileStream : public std::ifstream

7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line

25:     InFileStream();

26:     InFileStream(const char *filename);

27:     //- InFileStream(const InFileStream &copy);

45:     InFileStream(const InFileStream &copy);

38: class PWIZ_API_DECL BinaryIndexStream : public Index

42:     BinaryIndexStream(boost::shared_ptr<std::iostream> indexStreamPtr);

1: .checkStream <- function(s, yield=list())

7: test_Stream_producer <- function()

14: test_Stream_consumer <- function()

22: test_Stream_producer_consumer <- function()

9:     ## Stream() should produce a stream with only a producer

11:     .checkStream(Stream(p))

16:     ## Stream() should error with only a consumer (?)

19:     checkException(Stream(c))

24:     ## Stream should succeed with producer / consumer in any order

27:     .checkStream(s1 <- Stream(c, p))

31:     .checkStream(s2 <- Stream(p, c))

4246:   function d3_geo_pathProjectStream(project) {

3878:       var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);

3881:           lower48Stream.point(x, y);

3886:           lower48Stream.sphere();

3891:           lower48Stream.lineStart();

3896:           lower48Stream.lineEnd();

3901:           lower48Stream.polygonStart();

3906:           lower48Stream.polygonEnd();

3862:     var point, pointStream = {

3882:           alaskaStream.point(x, y);

3883:           hawaiiStream.point(x, y);

3887:           alaskaStream.sphere();

3888:           hawaiiStream.sphere();

3892:           alaskaStream.lineStart();

3893:           hawaiiStream.lineStart();

3897:           alaskaStream.lineEnd();

3898:           hawaiiStream.lineEnd();

3902:           alaskaStream.polygonStart();

3903:           hawaiiStream.polygonStart();

3907:           alaskaStream.polygonEnd();

3908:           hawaiiStream.polygonEnd();

3929: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;

3930: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;

3931: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;

4200:     var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;

4203:         if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));

4204:         if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);

4205:         d3.geo.stream(object, cacheStream);

4207:       return contextStream.result();

4211:       d3.geo.stream(object, projectStream(d3_geo_pathArea));

4216:       d3.geo.stream(object, projectStream(d3_geo_pathCentroid));

4221:       d3.geo.stream(object, projectStream(d3_geo_pathBounds));

4226:       projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;

4231:       contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);

4232:       if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);

4237:       pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);

4241:       cacheStream = null;

658:   std::ostream &getOutputStream () {

662:   std::ostream &getStatsStream () {

1814:         parameters.getOutputStream() << "# Program:mmquant v" << VERSION << "; Command:";

1816:           parameters.getOutputStream() << " \"" << arg << "\"";

1818:         parameters.getOutputStream() << "\nGeneid\tChr\tStart\tEnd\tStrand\tLength";

1821:         parameters.getOutputStream() << "Gene";

1824:         parameters.getOutputStream() << "\t" << sample;

1826:       parameters.getOutputStream() << "\n";

1828:           parameters.getOutputStream() << line.first;

1830:               parameters.getOutputStream() << "\t" << i;

1832:           parameters.getOutputStream() << "\n";

1923:     dumpStats(parameters.getStatsStream(), parameters.names, stats);

2427: sdfStream <- function(input, output, append=FALSE, fct, Nlines=10000, startline=1, restartNlines=10000, silen...(15 bytes skipped)...

2420: ## (6.8) Streaming Through SD Files ##

2422: ## Streaming function to compute descriptors for large SD Files without consuming much memory.

2433: 	## For restarting sdfStream at specific line assigned to startline argument. If assigned

2535: # sdfStream(input="test.sdf", output="matrix.xls", fct=desc, Nlines=1000)

2544: ## as character strings to APset or FPset objects (e.g. generated by sdfStream).

2575: ## Extracts specific molecules from SD File based on a line position index computed by the sdfStream function

2606: ## Usage: see sdfStream()

213: size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)

5687: ZSTD_CStream* ZSTD_createCStream(void)

5693: ZSTD_CStream* ZSTD_initStaticCStream(void *workspace, size_t workspaceSize)

5703: size_t ZSTD_freeCStream(ZSTD_CStream* zcs)

5729: size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)

5837: size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)

6060: size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)

6846: size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)

6854: size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)

5698: ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem)

5746: size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,

5768: size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,

5782: size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)

5795: size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,

5813: size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)

5822: size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)

5863: static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,

6103: static size_t ZSTD_CCtx_init_compressStream2(ZSTD_CCtx* cctx,

6201: size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,

6300: size_t ZSTD_compressStream2_simpleArgs (

1755: size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)

1775: size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams)

1792: static size_t ZSTD_estimateCStreamSize_internal(int compressionLevel)

1798: size_t ZSTD_estimateCStreamSize(int compressionLevel)

5712: size_t ZSTD_CStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX; }

5714: size_t ZSTD_CStreamOutSize(void)

3679:     U32 singleStream = litSize < 256;

3688:             if (!singleStream) cLitSizeEstimate += 6; /* multi-stream huffman uses 6-byte jump table */

5684: *  Streaming

5689:     DEBUGLOG(3, "ZSTD_createCStream");

5690:     return ZSTD_createCStream_advanced(ZSTD_defaultCMem);

5699: {   /* CStream and CCtx are now same object */

5727: /* ZSTD_resetCStream():

5736:     DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize);

5742: /*! ZSTD_initCStream_internal() :

5751:     DEBUGLOG(4, "ZSTD_initCStream_internal");

5766: /* ZSTD_initCStream_usingCDict_advanced() :

5767:  * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */

5773:     DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced");

5784:     DEBUGLOG(4, "ZSTD_initCStream_usingCDict");

5791: /* ZSTD_initCStream_advanced() :

5804:     DEBUGLOG(4, "ZSTD_initCStream_advanced");

5815:     DEBUGLOG(4, "ZSTD_initCStream_usingDict");

5829:     DEBUGLOG(4, "ZSTD_initCStream_srcSize");

5839:     DEBUGLOG(4, "ZSTD_initCStream");

5860: /** ZSTD_compressStream_generic():

5861:  *  internal function for all *compressStream*() variants

5877:     DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%i, srcSize = %zu", (int)flushMode, input->size - input->pos);

5903:             RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!");

6062:     FORWARD_IF_ERROR( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) , "");

6119:     DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");

6155:             DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",

6161:         DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);

6162:         FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(

6206:     DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);

6234:         FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, endOp, totalInputSize), "compressStream2 initialization failed");

6258:             flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);

6267:             FORWARD_IF_ERROR(flushMin, "ZSTDMT_compressStream_generic failed");

6285:         DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");

6294:     FORWARD_IF_ERROR( ZSTD_compressStream_generic(cctx, output, input, endOp) , "");

6295:     DEBUGLOG(5, "completed ZSTD_compressStream2");

6314:     /* ZSTD_compressStream2() will check validity of dstPos and srcPos */

6315:     {   size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);

6335:         size_t const result = ZSTD_compressStream2_simpleArgs(cctx,

6343:         FORWARD_IF_ERROR(result, "ZSTD_compressStream2_simpleArgs failed");

6802:     /* Transparent initialization stage, same as compressStream2() */

6805:     FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, ZSTD_e_end, srcSize), "CCtx initialization failed");

6837: static ZSTD_inBuffer inBuffer_forEndFlush(const ZSTD_CStream* zcs)

6844: /*! ZSTD_flushStream() :

6850:     return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush);

6857:     size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);

6858:     FORWARD_IF_ERROR(remainingToFlush , "ZSTD_compressStream2(,,ZSTD_e_end) failed");

6864:         DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush);

1783:         noRowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);

1785:         rowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);

1788:         return ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);

1795:     return ZSTD_estimateCStreamSize_usingCParams(cParams);

1803:         size_t const newMB = ZSTD_estimateCStreamSize_internal(level);

472:   std::fstream m_fileStream;

579:   int isFileOpen() { return (m_fileStream.is_open()? TSV_OK : TSV_ERR_FILEIO); }

581:   bool is_open() { return m_fileStream.is_open(); }

582:   bool good() { return m_fileStream.good(); }

356:     isStream <- FALSE

366:         isStream <- TRUE

400:     if (!isStream) {

738: typedef ZSTD_CCtx ZSTD_CStream;  /**< CCtx and CStream are now effectively same object (>= v1.3.0) */

860: typedef ZSTD_DCtx ZSTD_DStream;  /**< DCtx and DStream are now effectively same object (>= v1.3.0) */

1681:  *  Note : if streaming is init with function ZSTD_init?Stream_usingDict(),

2754:  *   - Stream history is not currently supported. All advanced compression APIs, including

90:     - unbounded multiple steps (described as Streaming compression)

304:  *   "sticky" parameters are applicable to `ZSTD_compress2()` and `ZSTD_compressStream*()` !

438: ...(7 bytes skipped)...                       * When nbWorkers >= 1, triggers asynchronous mode when invoking ZSTD_compressStream*() :

439:                               * ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,

441: ...(13 bytes skipped)...                 * (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end :

442:                               *  in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call).

549:  *           or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),

600:  * Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream().

660: *  Streaming

678: *  Streaming compression - HowTo

680: *  A ZSTD_CStream object is required to track streaming operation.

681: *  Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources.

682: *  ZSTD_CStream objects can be reused multiple times on consecutive compression operations.

683: *  It is recommended to re-use ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory.

685: *  For parallel execution, use one separate ZSTD_CStream per thread.

687: *  note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing.

696: *  Use ZSTD_compressStream2() with ZSTD_e_continue as many times as necessary to

713: *  using ZSTD_compressStream2() with ZSTD_e_flush. `output->pos` will be updated.

715: *  In which case, make some room to receive more compressed data, and call again ZSTD_compressStream2() with ZSTD_e_flush.

716: *  You must continue calling ZSTD_compressStream2() with ZSTD_e_flush until it returns 0, at which point you can change the

724: *  Calling ZSTD_compressStream2() with ZSTD_e_end instructs to finish a frame.

727: *  flush operation is the same, and follows same rules as calling ZSTD_compressStream2() with ZSTD_e_flush.

728: *  You must continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to

740: /*===== ZSTD_CStream management functions =====*/

741: ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream(void);

742: ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs);  /* accept NULL pointer */

744: /*===== Streaming compression functions =====*/

758: /*! ZSTD_compressStream2() : Requires v1.4.0+

759:  *  Behaves about the same as ZSTD_compressStream, with additional control on end directive.

780: ZSTDLIB_API size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,

787:  * They are not required : ZSTD_compressStream*() happily accepts any buffer size, for both input and output.

788:  * Respecting the recommended size just makes it a bit easier for ZSTD_compressStream*(),

805:  * It can be replaced by ZSTD_CCtx_reset() and ZSTD_compressStream2().

816:  * Note that ZSTD_initCStream() clears any previously set dictionary. Use the new API

819: ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel);

821:  * Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue).

822:  * NOTE: The return value is different. ZSTD_compressStream() returns a hint for

823:  * the next read size (if non-zero and not an error). ZSTD_compressStream2()

826: ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);

827: /*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush). */

828: ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);

829: /*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). */

830: ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);

834: *  Streaming decompression - HowTo

836: *  A ZSTD_DStream object is required to track streaming operations.

837: *  Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources.

838: *  ZSTD_DStream objects can be re-used multiple times.

840: *  Use ZSTD_initDStream() to start a new decompression operation.

844: *  Use ZSTD_decompressStream() repetitively to consume your input.

851: *  In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer.

862: /*===== ZSTD_DStream management functions =====*/

863: ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void);

864: ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds);  /* accept NULL pointer */

866: /*===== Streaming decompression functions =====*/

868: /*! ZSTD_initDStream() :

869:  * Initialize/reset DStream state for new decompression operation.

870:  * Call before new decompression operation using same DStream.

876: ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);

878: /*! ZSTD_decompressStream() :

879:  * Streaming decompression function.

886:  *   call ZSTD_decompressStream() again to flush remaining data to output.

893: ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);

1023:  * ZSTD_compressStream2(), and ZSTD_decompressDCtx().

1132:  *  End of frame is reached when ZSTD_decompressStream() returns 0.

1137:  *           reached when ZSTD_decompressStream() returns 0.

1153: ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);

1154: ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);

1677:  *  Note : CStream size estimation is only correct for single-threaded compression.

1678:  *  ZSTD_DStream memory budget depends on window Size.

1721:  *                 ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().

1726: ZSTDLIB_STATIC_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticCCtx() */

1729: ZSTDLIB_STATIC_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticDCtx() */

1760: ZSTDLIB_STATIC_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);

1762: ZSTDLIB_STATIC_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);

2232:  *  - ZSTD_compressStream2() : Do compression using the CCtx.

2285: /*! ZSTD_compressStream2_simpleArgs() :

2286:  *  Same as ZSTD_compressStream2(),

2291: ZSTDLIB_STATIC_API size_t ZSTD_compressStream2_simpleArgs (

2444: /*! ZSTD_decompressStream_simpleArgs() :

2445:  *  Same as ZSTD_decompressStream(),

2450: ZSTDLIB_STATIC_API size_t ZSTD_decompressStream_simpleArgs (

2463: /*=====   Advanced Streaming compression functions  =====*/

2465: /*! ZSTD_initCStream_srcSize() :

2479: size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs,

2483: /*! ZSTD_initCStream_usingDict() :

2497: size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs,

2501: /*! ZSTD_initCStream_advanced() :

2515: size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,

2520: /*! ZSTD_initCStream_usingCDict() :

2530: size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);

2532: /*! ZSTD_initCStream_usingCDict_advanced() :

2539:  * same as ZSTD_initCStream_usingCDict(), with control over frame parameters.

2546: size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,

2551: /*! ZSTD_resetCStream() :

2555:  * Note: ZSTD_resetCStream() interprets pledgedSrcSize == 0 as ZSTD_CONTENTSIZE_UNKNOWN, but

2561:  *  Note that zcs must be init at least once before using ZSTD_resetCStream().

2571: size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);

2607: /*=====   Advanced Streaming decompression functions  =====*/

2618: ZSTDLIB_STATIC_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);

2629: ZSTDLIB_STATIC_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict);

2639: ZSTDLIB_STATIC_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);

2654:  * ZSTD_compress2() or ZSTD_compressStream2() as usual, and transparently benefits

2787:  * APIs which respect advanced parameters, such as compress2() and compressStream2().

2812: *  Please use the normal streaming API instead: ZSTD_compressStream2,

2813: *  and ZSTD_decompressStream.

799: ZSTDLIB_API size_t ZSTD_CStreamInSize(void);    /**< recommended size for input buffer */

800: ZSTDLIB_API size_t ZSTD_CStreamOutSize(void);   /**< recommended size for output buffer. Guarantee to successfully flush at least o...(32 bytes skipped)...

895: ZSTDLIB_API size_t ZSTD_DStreamInSize(void);    /*!< recommended size for input buffer */

896: ZSTDLIB_API size_t ZSTD_DStreamOutSize(void);   /*!< recommended size for output buffer. Guarantee to successfully flush at least o...(42 bytes skipped)...

1646:  *  Note : Unlike ZSTD_estimateCStreamSize*(), this estimate

1671: /*! ZSTD_estimateCStreamSize() :

1672:  *  ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one.

1674:  *  If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.

1675:  *  ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionL...(5 bytes skipped)...

1676:  *  ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-thread...(97 bytes skipped)...

1679:  *  This information can be passed manually, using ZSTD_estimateDStreamSize,

1680:  *  or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();

1685:  *  ZSTD_estimateCStreamSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1.

1686:  *  Note 3 : ZSTD_estimateCStreamSize* functions are not compatible with the Block-Level Sequence Producer API at this time.

1689: ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize(int compressionLevel);

1690: ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);

1691: ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);

1692: ZSTDLIB_STATIC_API size_t ZSTD_estimateDStreamSize(size_t windowSize);

1693: ZSTDLIB_STATIC_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);

1333: LZ4_stream_t* LZ4_createStream(void)

1353: LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)

1369: void LZ4_resetStream (LZ4_stream_t* LZ4_stream)

1379: int LZ4_freeStream (LZ4_stream_t* LZ4_stream)

1375: void LZ4_resetStream_fast(LZ4_stream_t* ctx) {

2168: LZ4_streamDecode_t* LZ4_createStreamDecode(void)

2175: int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)

2188: int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)

2377: int LZ4_sizeofStreamState() { return LZ4_STREAMSIZE; }

2379: int LZ4_resetStreamState(void* state, char* inputBuffer)

1182:     LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;

1208:  * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of

1278:     LZ4_initStream(&ctx, sizeof(ctx));

1294:     void* const s = LZ4_initStream(state, sizeof (*state));

1330: *  Streaming functions

1337:     DEBUGLOG(4, "LZ4_createStream %p", lz4s);

1339:     LZ4_initStream(lz4s, sizeof(*lz4s));

1355:     DEBUGLOG(5, "LZ4_initStream");

1367: /* resetStream is now deprecated,

1368:  * prefer initStream() which is more general */

1371:     DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);

1382:     DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);

1403:     LZ4_resetStream(LZ4_dict);

1431: void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream) {

1432:     const LZ4_stream_t_internal* dictCtx = dictionaryStream == NULL ? NULL :

1433:         &(dictionaryStream->internal_donotuse);

1436:              workingStream, dictionaryStream,

1439:     /* Calling LZ4_resetStream_fast() here makes sure that changes will not be

1440:      * erased by subsequent calls to LZ4_resetStream_fast() in case stream was

1443:     LZ4_resetStream_fast(workingStream);

1451:         if (workingStream->internal_donotuse.currentOffset == 0) {

1452:             workingStream->internal_donotuse.currentOffset = 64 KB;

1461:     workingStream->internal_donotuse.dictCtx = dictCtx;

2375: /* Obsolete Streaming functions */

2382:     LZ4_resetStream((LZ4_stream_t*)state);

2389:     return LZ4_createStream();

2182: /*! LZ4_setStreamDecode() :

2222:     and indicate where it stands using LZ4_setStreamDecode()

6898:     function geoStream(object, stream) {

7424:     function circleStream(stream, radius, delta, direction, t0, t1) {

8978:     function TransformStream() {}

9343:             point, pointStream = {point: function(x, y) { point = [x, y]; }};

6915:     var areaStream = {

6921:             areaStream.lineStart = areaRingStart;

6922:             areaStream.lineEnd = areaRingEnd;

6935:         areaStream.point = areaPointFirst;

6943:         areaStream.point = areaPoint;

6972:         geoStream(object, areaStream);

7020:     var boundsStream = {

7025:             boundsStream.point = boundsRingPoint;

7026:             boundsStream.lineStart = boundsRingStart;

7027:             boundsStream.lineEnd = boundsRingEnd;

7029:             areaStream.polygonStart();

7032:             areaStream.polygonEnd();

7033:             boundsStream.point = boundsPoint;

7034:             boundsStream.lineStart = boundsLineStart;

7035:             boundsStream.lineEnd = boundsLineEnd;

7099:         boundsStream.point = linePoint;

7104:         boundsStream.point = boundsPoint;

7115:         areaStream.point(lambda, phi);

7120:         areaStream.lineStart();

7125:         areaStream.lineEnd();

7151:         geoStream(feature, boundsStream);

7200:     var centroidStream = {

7206:             centroidStream.lineStart = centroidRingStart;

7207:             centroidStream.lineEnd = centroidRingEnd;

7210:             centroidStream.lineStart = centroidLineStart;

7211:             centroidStream.lineEnd = centroidLineEnd;

7230:         centroidStream.point = centroidLinePointFirst;

7239:         centroidStream.point = centroidLinePoint;

7258:         centroidStream.point = centroidPoint;

7264:         centroidStream.point = centroidRingPointFirst;

7269:         centroidStream.point = centroidPoint;

7275:         centroidStream.point = centroidRingPoint;

7310:         geoStream(object, centroidStream);

7470:             circleStream(stream, r, p, 1);

7906:             circleStream(stream, radius, delta, direction, from, to);

8182:             var activeStream = stream,

8183:                 bufferStream = clipBuffer(),

8192:             var clipStream = {

8201:                 if (visible(x, y)) activeStream.point(x, y);

8220:                 activeStream = bufferStream, segments = [], polygon = [], clean = true;

8239:                 activeStream = stream, segments = polygon = ring = null;

8243:                 clipStream.point = linePoint;

8256:                     if (v__ && v_) bufferStream.rejoin();

8257:                     segments.push(bufferStream.result());

8259:                 clipStream.point = point;

8260:                 if (v_) activeStream.lineEnd();

8270:                         activeStream.lineStart();

8271:                         activeStream.point(x, y);

8274:                     if (v && v_) activeStream.point(x, y);

8280:                                 activeStream.lineStart();

8281:                                 activeStream.point(a[0], a[1]);

8283:                             activeStream.point(b[0], b[1]);

8284:                             if (!v) activeStream.lineEnd();

8287:                             activeStream.lineStart();

8288:                             activeStream.point(x, y);

8296:             return clipStream;

8306:             cacheStream,

8311:                 return cache && cacheStream === stream ? cache : cache = clipRectangle(x0, y0, x1, y1)(cacheStream = stream);

8314: ...(16 bytes skipped)...return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]];

8324:     var lengthStream = {

8334:         lengthStream.point = lengthPointFirst;

8335:         lengthStream.lineEnd = lengthLineEnd;

8339:         lengthStream.point = lengthStream.lineEnd = noop$1;

8345:         lengthStream.point = lengthPoint;

8364:         geoStream(object, lengthStream);

8607:     var areaStream$1 = {

8612:             areaStream$1.lineStart = areaRingStart$1;

8613:             areaStream$1.lineEnd = areaRingEnd$1;

8616:             areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$1;

8628:         areaStream$1.point = areaPointFirst$1;

8632:         areaStream$1.point = areaPoint$1;

8650:     var boundsStream$1 = {

8686:     var centroidStream$1 = {

8691:             centroidStream$1.lineStart = centroidRingStart$1;

8692:             centroidStream$1.lineEnd = centroidRingEnd$1;

8695:             centroidStream$1.point = centroidPoint$1;

8696:             centroidStream$1.lineStart = centroidLineStart$1;

8697:             centroidStream$1.lineEnd = centroidLineEnd$1;

8718:         centroidStream$1.point = centroidPointFirstLine;

8722:         centroidStream$1.point = centroidPointLine;

8735:         centroidStream$1.point = centroidPoint$1;

8739:         centroidStream$1.point = centroidPointFirstRing;

8747:         centroidStream$1.point = centroidPointRing;

8817:     var lengthStream$1 = {

8820:             lengthStream$1.point = lengthPointFirst$1;

8824:             lengthStream$1.point = noop$1;

8840:         lengthStream$1.point = lengthPoint$1;

8912:             projectionStream,

8913:             contextStream;

8917:                 if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));

8918:                 geoStream(object, projectionStream(contextStream));

8920:             return contextStream.result();

8924:             geoStream(object, projectionStream(areaStream$1));

8925:             return areaStream$1.result();

8929:             geoStream(object, projectionStream(lengthStream$1));

8930:             return lengthStream$1.result();

8934:             geoStream(object, projectionStream(boundsStream$1));

8935:             return boundsStream$1.result();

8939:             geoStream(object, projectionStream(centroidStream$1));

8940:             return centroidStream$1.result();

8944:             return arguments.length ? (projectionStream = _ == null ? (projection = null, identity$4) : (projection = _).stream, path) : projection;

8949:             contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _);

8950:             if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);

8956:             pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);

8971:             var s = new TransformStream;

8980:     TransformStream.prototype = {

8981:         constructor: TransformStream,

8994:         geoStream(object, projection.stream(boundsStream$1));

8995:         fitBounds(boundsStream$1.result());

9083:             var resampleStream = {

9087:                 polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },

9088:                 polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }

9098:                 resampleStream.point = linePoint;

9109:                 resampleStream.point = point;

9115:                 resampleStream.point = ringPoint;

9116:                 resampleStream.lineEnd = ringEnd;

9121:                 resampleStream.point = linePoint;

9126:                 resampleStream.lineEnd = lineEnd;

9130:             return resampleStream;

9163:             cacheStream;

9180:             return cache && cacheStream...(9 bytes skipped)...am ? cache : cache = transformRadians(transformRotate(rotate)(preclip(projectResample(postclip(cacheStream = stream)))));

9244:             cache = cacheStream = null;

9339:             cacheStream,

9363:             return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);

9385:                 .stream(pointStream);

9390:                 .stream(pointStream);

9395:                 .stream(pointStream);

9417:             cache = cacheStream = null;

9621:             cacheStream,

9625:             cache = cacheStream = null;

9631:                 return cache && cacheStream === stream ? cache : cache = transform$$1(postclip(cacheStream = stream));

16942:     exports.geoStream = geoStream;

52: } fafStream;

207: } faStream;

215: void faStream_destroy(faStream *fa)

275: faStream * faStream_init(const char* filename, unsigned k, unsigned mode)

135: // fasta Stream

54: static inline unsigned faf_isEof(fafStream *faf) { return faf->status & faf_file_eof; }

55: static inline unsigned faf_isOpen(fafStream *faf)

62: static fafStream* faf_stream_init(const char* filename, unsigned mode)

64: 	// Construct fafStream object from opened file

65: 	fafStream *faf = calloc(sizeof(fafStream), 1);

87: static void faf_destroy(fafStream *faf)

99: static size_t inline faf_read(fafStream *faf, char *dest, unsigned size)

187: 	fafStream *fasta;

230: int fas_fill(faStream *fa)

279: 		printf("[faStream_init] k > fas_size!\n");

283: 	faStream *fa = calloc(sizeof(faStream), 1);

292: 		printf("[faStream_init] Cannot open file '%s'!\n", filename);

293: 		faStream_destroy(fa);

308: 		printf("[faStream_init] Initial array filling failed!\n");

309: 		faStream_destroy(fa);

321: static inline int fas_fas_end(faStream *fa)		{ return fa->ffc == 0; }

322: static inline int fas_nuc_end(faStream *fa)		{ return fa->fnc == 0; }

333: static inline int fas_checkNewLine(faStream *fa)

343: static inline int fas_skipNewLine(faStream *fa)

366: static inline int fas_skipLine(faStream *fa)

386: static inline int fas_checkNewSeq(faStream *fa)

399: static inline int fas_skipSeqHeader(faStream *fa)

412: static inline int fas_checkComment(faStream *fa)

422: static inline int fas_skipComment(faStream *fa)

435: static inline int fas_checkN(faStream *fa)

445: static inline int fas_skipN(faStream *fa)

496: char * fas_getSeqName(faStream *fa)

551: int fas_initSeq(faStream *fa)

592: static inline int fas_returnFromTranfer(faStream *fa)

626: int fas_TransferNucArray(faStream *fa)

697: int fa_empty(faStream *fa)    { return (fa->stream_state & fas_stream_empty); }

698: int fa_NucReady(faStream *fa) { return (fa->stream_state & fas_nuc_ready);    }

699: int fa_K_Ready(faStream *fa)  { return (fa->stream_state & fas_loc_kReady);   }

700: int fa_NewSeq(faStream *fa)   { return (fa->stream_state & fas_loc_newSeq);   }

701: int fa_N_Nuc(faStream *fa)    { return (ACGTN[(unsigned)*fa->iter] == nval);  }

704: void fa_unsetNucReady(faStream *fa)

3639:   function d3_geo_pathProjectStream(project) {

3271:       var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);

3274:           lower48Stream.point(x, y);

3279:           lower48Stream.sphere();

3284:           lower48Stream.lineStart();

3289:           lower48Stream.lineEnd();

3294:           lower48Stream.polygonStart();

3299:           lower48Stream.polygonEnd();

3255:     var point, pointStream = {

3275:           alaskaStream.point(x, y);

3276:           hawaiiStream.point(x, y);

3280:           alaskaStream.sphere();

3281:           hawaiiStream.sphere();

3285:           alaskaStream.lineStart();

3286:           hawaiiStream.lineStart();

3290:           alaskaStream.lineEnd();

3291:           hawaiiStream.lineEnd();

3295:           alaskaStream.polygonStart();

3296:           hawaiiStream.polygonStart();

3300:           alaskaStream.polygonEnd();

3301:           hawaiiStream.polygonEnd();

3322: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;

3323: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;

3324: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;

3593:     var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;

3596:         if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));

3597:         if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);

3598:         d3.geo.stream(object, cacheStream);

3600:       return contextStream.result();

3604:       d3.geo.stream(object, projectStream(d3_geo_pathArea));

3609:       d3.geo.stream(object, projectStream(d3_geo_pathCentroid));

3614:       d3.geo.stream(object, projectStream(d3_geo_pathBounds));

3619:       projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;

3624:       contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);

3625:       if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);

3630:       pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);

3634:       cacheStream = null;

327:     isStream <- FALSE

350:         isStream <- TRUE

363:         if (!isStream) {

140: 		COREARRAY_FORCEINLINE CdBufStream *BufStream()

177: 		CdBufStream *_BufStream;

70: 		void Initialize(CdStream &Stream, bool CanRead, bool CanWrite);

137: 		void CopyTo(CdBufStream &Obj, SIZE64 Pos, SIZE64 Count);

141: 			{ return _BufStream; }

299: struct bbiSumOutStream

309: struct bbiSumOutStream *bbiSumOutStreamOpen(int allocCount, FILE *f, boolean doCompress);

310: /* Open new bbiSumOutStream. */

312: void bbiSumOutStreamClose(struct bbiSumOutStream **pStream);

313: /* Free up bbiSumOutStream */

315: void bbiSumOutStreamWrite(struct bbiSumOutStream *stream, struct bbiSummary *sum);

322: 	struct bbiSumOutStream *stream);

251:     isStream <- FALSE

283:         isStream <- TRUE

310:     if (!isStream) {

823: static size_t HUF_initCStream(HUF_CStream_t* bitC,

940: static size_t HUF_closeCStream(HUF_CStream_t* bitC)

1189: typedef enum { HUF_singleStream, HUF_fourStreams } HUF_nbStreams_e;

817: } HUF_CStream_t;

790: /** HUF_CStream_t:

791:  * Huffman uses its own BIT_CStream_t implementation.

792:  * There are three major differences from BIT_CStream_t:

819: /**! HUF_initCStream():

838:  *              See the HUF_CStream_t docs for the format.

844: FORCE_INLINE_TEMPLATE void HUF_addBits(HUF_CStream_t* bitC, HUF_CElt elt, int idx, int kFast)

878: FORCE_INLINE_TEMPLATE void HUF_zeroIndex1(HUF_CStream_t* bitC)

888: FORCE_INLINE_TEMPLATE void HUF_mergeIndex1(HUF_CStream_t* bitC)

904: FORCE_INLINE_TEMPLATE void HUF_flushBits(HUF_CStream_t* bitC, int kFast)

937: /*! HUF_closeCStream() :

938:  *  @return Size of CStream, in bytes,

952: HUF_encodeSymbol(HUF_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable, int idx, int fast)

958: HUF_compress1X_usingCTable_internal_body_loop(HUF_CStream_t* bitC,

1033:     HUF_CStream_t bitC;

1037:     { size_t const initErr = HUF_initCStream(&bitC, op, (size_t)(oend-op));

1084:     return HUF_closeCStream(&bitC);

1196:     size_t const cSize = (nbStreams==HUF_singleStream) ?

1415:                                  maxSymbolValue, huffLog, HUF_singleStream,

1194:                 HUF_nbStreams_e nbStreams, const HUF_CElt* CTable, const int flags)

1301:                        HUF_nbStreams_e nbStreams,

1327:                                            nbStreams, oldHufTable, flags);

1363:                                            nbStreams, oldHufTable, flags);

1392:                                                    nbStreams, oldHufTable, flags);

1404:                                        nbStreams, table->CTable, flags);

1432:                                  maxSymbolValue, huffLog, HUF_fourStreams,

1486: LZ4_stream_t* LZ4_createStream(void)

1507: LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)

1519: void LZ4_resetStream (LZ4_stream_t* LZ4_stream)

1530: int LZ4_freeStream (LZ4_stream_t* LZ4_stream)

1525: void LZ4_resetStream_fast(LZ4_stream_t* ctx) {

2462: LZ4_streamDecode_t* LZ4_createStreamDecode(void)

2468: int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)

2482: int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)

2699: int LZ4_sizeofStreamState(void) { return sizeof(LZ4_stream_t); }

2701: int LZ4_resetStreamState(void* state, char* inputBuffer)

201:  *  - lz4   : LZ4_createStream, LZ4_freeStream,

1348:     LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;

1375:  * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of

1446:     void* const s = LZ4_initStream(state, sizeof (*state));

1482: *  Streaming functions

1490:     DEBUGLOG(4, "LZ4_createStream %p", lz4s);

1492:     LZ4_initStream(lz4s, sizeof(*lz4s));

1509:     DEBUGLOG(5, "LZ4_initStream");

1517: /* resetStream is now deprecated,

1518:  * prefer initStream() which is more general */

1521:     DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);

1533:     DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);

1555:     LZ4_resetStream(LZ4_dict);

1583: void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream)

1585:     const LZ4_stream_t_internal* dictCtx = (dictionaryStream == NULL) ? NULL :

1586:         &(dictionaryStream->internal_donotuse);

1589:              workingStream, dictionaryStream,

1598:         if (workingStream->internal_donotuse.currentOffset == 0) {

1599:             workingStream->internal_donotuse.currentOffset = 64 KB;

1608:     workingStream->internal_donotuse.dictCtx = dictCtx;

2697: /* Obsolete Streaming functions */

2704:     LZ4_resetStream((LZ4_stream_t*)state);

2712:     return LZ4_createStream();

202:  *            LZ4_createStreamDecode, LZ4_freeStreamDecode, LZ4_create (deprecated)

203:  *  - lz4hc : LZ4_createStreamHC, LZ4_freeStreamHC,

2476: /*! LZ4_setStreamDecode() :

2521:     and indicate where it stands using LZ4_setStreamDecode()

370: getRNGStream <- function() {

379: setRNGStream <- function(seed = NULL) {

385: generateRNGStreams <- function(n = 1) {

387: 	s <- getRNGStream()

396: 			s <- nextRNGStream(seeds[[i - 1]])

303: RngStream::RngStream (const char *s) : name (s)

327: void RngStream::ResetStartStream ()

325: // Reset Stream to beginning of Stream.

335: // Reset Stream to beginning of SubStream.

345: // Reset Stream to NextSubStream.

3:  * File:           RngStream.cpp for multiple streams of Random Numbers

242: double RngStream::U01 ()

271: double RngStream::U01d ()

292: // declared RngStream, unless SetPackageSeed is called.

294: double RngStream::nextSeed[6] =

309:    state of the stream, the starting state of the current SubStream, and the

313:    will be the seed of the next declared RngStream. */

337: void RngStream::ResetStartSubstream ()

347: void RngStream::ResetNextSubstream ()

357: bool RngStream::SetPackageSeed (const unsigned long seed[6])

368: bool RngStream::SetSeed (const unsigned long seed[6])

384: void RngStream::AdvanceState (long e, long c)

415: void RngStream::GetState (unsigned long seed[6]) const

424: void RngStream::WriteState () const

439: void RngStream::WriteStateFull () const

443:     cout << "The RngStream";

470: void RngStream::IncreasedPrecis (bool incp)

477: void RngStream::SetAntithetic (bool a)

486: double RngStream::RandU01 ()

498: int RngStream::RandInt (int low, int high)

1460: bool paramRange::MergePartialFromCodedStream(

1810: bool Range::MergePartialFromCodedStream(

2113: bool rangeGate::MergePartialFromCodedStream(

2391: bool MultiRangeGate::MergePartialFromCodedStream(

2724: bool paramPoly::MergePartialFromCodedStream(

3077: bool polygonGate::MergePartialFromCodedStream(

3384: bool coordinate::MergePartialFromCodedStream(

3729: bool ellipseGate::MergePartialFromCodedStream(

4131: bool BOOL_GATE_OP::MergePartialFromCodedStream(

4471: bool boolGate::MergePartialFromCodedStream(

4740: bool clusterGate::MergePartialFromCodedStream(

5029: bool quadGate::MergePartialFromCodedStream(

5519: bool gate::MergePartialFromCodedStream(

6100: bool POPSTATS::MergePartialFromCodedStream(

6499: bool calibrationTable::MergePartialFromCodedStream(

7150: bool biexpTrans::MergePartialFromCodedStream(

7573: bool fasinhTrans::MergePartialFromCodedStream(

7978: bool scaleTrans::MergePartialFromCodedStream(

8311: bool flinTrans::MergePartialFromCodedStream(

8628: bool logTrans::MergePartialFromCodedStream(

8993: bool logGML2Trans::MergePartialFromCodedStream(

9334: bool logicleTrans::MergePartialFromCodedStream(

10043: bool transformation::MergePartialFromCodedStream(

10821: bool trans_pair::MergePartialFromCodedStream(

11195: bool trans_local::MergePartialFromCodedStream(

11609: bool POPINDICES::MergePartialFromCodedStream(

12094: bool nodeProperties::MergePartialFromCodedStream(

12578: bool treeNodes::MergePartialFromCodedStream(

12875: bool populationTree::MergePartialFromCodedStream(

13247: bool COMP::MergePartialFromCodedStream(

13908: bool PARAM::MergePartialFromCodedStream(

14432: bool GatingHierarchy::MergePartialFromCodedStream(

14868: bool CytoFrame::MergePartialFromCodedStream(

15151: bool TRANS_TBL::MergePartialFromCodedStream(

15563: bool GatingSet::MergePartialFromCodedStream(

1461:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

1533:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

1811:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

1868:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

2114:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

2156:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

2392:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

2449:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

2725:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

2783:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

3078:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

3131:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

3385:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

3442:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

3730:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

3807:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

4132:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

4205:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

4472:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

4514:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

4741:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

4787:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

5030:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

5090:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

5520:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

5670:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

6101:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

6160:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

6500:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

6652:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

6741:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

6754:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

6767:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

6780:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

6793:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

7151:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

7247:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

7574:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

7670:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

7979:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

8049:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

8312:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

8369:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {