ROOT logo
#ifndef __HZIP__
#define __HZIP__



#include "TObject.h"
#include "TFile.h"
#include "TSystem.h"
#include "TString.h"
#include "TRegexp.h"
#include "TArchiveFile.h"
#include "TArchiveFile.h"
#include "TList.h"
#include "TObjString.h"
#include "TObjArray.h"
#include "TChain.h"
#include "TChainElement.h"

#include <wordexp.h>

#include <iomanip>
#include <iostream>
#include <fstream>

using namespace std;






class HZip : public TObject {

public:
    HZip(){};
    virtual ~HZip(){};

    static TObjArray* glob(TString pattern)
    {
	// Expand 'pattern' as it would be done by the shell (see sh(1)):
	// '*', '?', '~', '$ENVIRONMENT_VARIABLE' and '[', ']' are expanded. In case
	// the expansion is successful, a TObjArray of TObjStrings with the
	// names of all existing files is returned - otherwise NULL.
	//
	// The returned TObjArray must be deleted by the caller of the function!
	//
	// This example returns all existing .root files in /tmp as well as all .root
	// files in your home directory starting with the characters 'a', 'b', 'c'
	// and 'e':
	//
	// TObjArray* files = HTool::glob( "/tmp/*.root $HOME/[a-c,e]*.root" );
	// if (files)
	// {
	//    TObjString* name = NULL;
	//    TIterator*  file = files->MakeIterator();
	//    while ((name = (TObjString*)file->Next()))
	//    {
	//       Char_t* input = name->GetString.Data(); ...
	//    }
	//    delete files;
	// }

	wordexp_t  file_list;
	Char_t**   file;
	TObjArray* filenames = NULL;

	if (pattern.IsNull())
	    return NULL;

	if (::wordexp( pattern.Data(), &file_list, 0 ))
	{
	    ::wordfree( &file_list );
	    return NULL;
	}

	file      = file_list.we_wordv;
	filenames = new TObjArray;

	for (UInt_t i = 0; i < file_list.we_wordc; i++)
	{
	    // check if files real exist, since ::wordexp(3) returns the unexpanded
	    // pattern, if e.g. the path does not exist
	    if (!gSystem->AccessPathName( file[i] ))
		filenames->Add( new TObjString( file[i] ) );
	}

	::wordfree( &file_list );
	if (filenames->GetEntries() == 0)
	{
	    delete filenames;
	    filenames = NULL;
	}

	return filenames;
    }

    static TObjArray* readFileList(TString listfile)
    {
	// read inputfiles form list (one file per line)
	// and add them to an TObjArray. The pointer to
	// the array is returned. In case of an error or
	// if no files are contained the pointer is NULL.
        // The user must take care of deleting the array.

 	if(gSystem->AccessPathName(listfile)){
  	    printf("Error: readFile() : list file does not exist!");
	    return NULL;
	}

	Char_t line[1000];
	ifstream inp;

	TObjArray* filenames = new TObjArray;

	inp.open(listfile.Data());
	TString name;
	while(!inp.eof()){
	    inp.getline (line, 1000);
	    name = line;

	    if(gSystem->AccessPathName(name)){
		printf("Error: readFileList() : file %s does not exist!",name.Data());
		continue;
	    }
	    filenames->Add( new TObjString( name ) );
	}
	inp.close();

	if (filenames->GetEntries() == 0) {
	    delete filenames;
	    filenames = NULL;
	}
	return filenames;
    }

    static Bool_t chainToTObjArray(TChain* chain=0,TObjArray* filenames=0)
    {
        //  add all filenames of TChain to TObjArray
	if(chain == 0){
	    printf("Error: chainToTObjArray() : TChain pointer is NULL!");
	    return kFALSE;
	}
        if(filenames == 0){
	    printf("Error: chainToTObjArray() : TObjArray pointer is NULL!");
	    return kFALSE;
	}

	TObjArray* elements = chain->GetListOfFiles();
	Int_t nfiles        = elements->GetEntries();
	for(Int_t i=0;i<nfiles;i++){
	    TChainElement* element = (TChainElement*)elements->At(i);
	    filenames->Add( new TObjString( element->GetTitle() ) );
	}
        return kTRUE;
    }


    static Bool_t exists(TString name,Bool_t silent=kFALSE,Bool_t isZip=kTRUE)
    {
	// returns kTRUE if file exists and ends with .zip

	if(isZip && name.EndsWith(".zip") == 0) {
	    if(!silent) printf("Error: File %s does not end with .zip\n!",name.Data());
	    return kFALSE;
	}
	if(gSystem->AccessPathName(name.Data()) != 0) {
	    if(!silent) printf("Error: File %s does not exist\n!",name.Data());
	    return kFALSE;
	}
	return kTRUE;
    }

    static Bool_t splitName(TString fullname, TString& zipname,TString& membername)
    {
	// if filename is   .zip#membername the
	// name is splitted into the zip file name and
	// the archive member name. return kTRUE
        // if success els kFALSE

	if(fullname.Contains(".zip#") != 0){

	    zipname    = fullname;
	    zipname.Remove(zipname.First('#'));

	    membername = fullname;
	    membername.Replace(0,membername.First('#') + 1,"");

            return kTRUE;
	}
	printf("Error: isInside() : Filename does not contain .zip#membername!\n");
	return kFALSE;
    }

    static Bool_t isInside(TString name, Bool_t print=kFALSE)
    {
	// test if the member  (format: zipfilename.zip#membername)
	// is inside the zip file. Return kTRUE if
        // success else kFALSE

	TString zipname;
	TString membername;

	if(!HZip::splitName(name,zipname,membername)) { return kFALSE; }

	if(!HZip::exists(zipname)) return kFALSE;

	Bool_t found = kFALSE;

	TFile* fzip = TFile::Open(zipname.Data());
	if(fzip) {
	    TArchiveFile* archive = fzip->GetArchive();
	    if(archive){
		TObjArray* members = archive->GetMembers();
		if(members->FindObject(membername.Data()) == 0) {
		    if(print) printf("Info: isInside() : File %s not found ind zipfile %s\n",membername.Data(),zipname.Data());
		    found = kFALSE;
		} else {
		    if(print) printf("Info: isInside() : File %s found ind zipfile %s\n"    ,membername.Data(),zipname.Data());
		    found = kTRUE;
		}
	    } else {
		printf("Error: isInside() : Retrieved NULL pointer for Archive!\n");
	    }
	    fzip->Close();
	    delete fzip;

	}
	return found;
    }

    static Bool_t isInside(TString zipname, TString membername ,Bool_t print=kFALSE)
    {
	// test if the member is inside the zip file.
	// Return kTRUE if success else kFALSE
	TString name = zipname + "#" + membername;
	return  isInside(name,print);
    }

    static Int_t list(TString name, TString filter=".*",Int_t size=0,Int_t time=0)
    {
	// lists the members of the zip file which pass
	// the name filter (see TRegexp). returns the number
        // of matched files

	if(!HZip::exists(name)) return 0;

	TFile* fzip = TFile::Open(name.Data());
	if(fzip) {
	    TArchiveFile* archive = fzip->GetArchive();
	    if(archive){
		cout<<"-------------------------------------------------------------------------------"<<endl;
		cout<<"Listing all file inside zip file "<<name.Data()<<" (matching "<<filter.Data()<<") :"<<endl;
		TObjArray* members = archive->GetMembers();
		TString fname = "";
		TRegexp expr(filter);
		Int_t ct = 0;
		for(Int_t i = 0; i < members->GetEntries(); i++){
		    TArchiveMember* member = (TArchiveMember*) members->At(i);
		    fname = member->GetName();
		    if(fname(expr) != ""){
			cout<<setw(5)<<ct
			    <<" size "   <<setw(12)<<member->GetCompressedSize()
			    <<" mod time "<<member->GetModTime().AsString()
			    <<" "<<member->GetName()<<endl;
			ct++;
		    }
		}
		cout<<"-------------------------------------------------------------------------------"<<endl;
		return ct;

	    } else {
		printf("Error: list() : Retrived NULL pointer for Archive!\n");
	    }
	    fzip->Close();
	    delete fzip;
	}
        return 0;
    }

    static Int_t getList(TString name,TList* list,TString filter=".*",Int_t size=0,Int_t time=0)
    {
	// fills a list with the members of the zip file which pass
	// the name filter (see TRegexp). returns the number
        // of matched files

	if(!HZip::exists(name)) return 0;

	TFile* fzip = TFile::Open(name.Data());
	if(fzip) {
	    TArchiveFile* archive = fzip->GetArchive();
	    if(archive){
		TObjArray* members = archive->GetMembers();
		TString fname = "";
		TRegexp expr(filter);
		Int_t ct = 0;
		for(Int_t i = 0; i < members->GetEntries(); i++){
		    TArchiveMember* member = (TArchiveMember*) members->At(i);
		    fname = member->GetName();
		    if(fname(expr) != ""){

			list->Add(new TObjString(member->GetName()));
			ct++;
		    }
		}
		return ct;

	    } else {
		printf("Error: list() : Retrived NULL pointer for Archive!\n");
	    }
	    fzip->Close();
	    delete fzip;
	}
        return 0;
    }

    static Bool_t makeChain(TString zipname,TChain* chain = 0,TString filter=".*",Int_t size=0,Int_t time=0)
    {
	// adds all root members of the zip file matching the filter
        // to TChain (has to be created before)

	if(chain == 0){
	    printf("Error: makeChain() : TChain pointer is NULL!");
	    return kFALSE;
	}

	TList* list = new TList();
	HZip::getList(zipname,list,filter,size,time);
        HZip::list(zipname,filter,size,time);

	TObjString* member;

	TIterator* iter = list->MakeIterator();

	while((member = (TObjString*)iter->Next()) != 0){
	    TString membername = member->GetString();
	    TString fullname = zipname + "#" + membername;
            chain->Add(fullname.Data());
	}
	delete iter;
	delete list;

	return kTRUE;
    }

    static Bool_t makeChainGlob(TString expressionzip,TChain* chain = 0,TString filter=".*",Int_t size=0,Int_t time=0)
    {
	// adds all root members match the filter of all zip files matching the expression
        // to TChain (has to be created before)
	if(chain == 0){
	    printf("Error: makeChainGlob() : TChain pointer is NULL!");
	    return kFALSE;
	}

        TObjArray* files = HZip::glob(expressionzip);

        Int_t nfiles = files->GetEntries();
	if(nfiles == 0) return kFALSE;

	for(Int_t j=0;j<nfiles;j++){
               TString fna = ((TObjString*)(files->At(j)))->GetString();
               HZip::makeChain(fna,chain,filter,size,time);
	}

        delete files;
	return kTRUE;
    }

    static Bool_t makeChainList(TString listfile,TChain* chain = 0,TString filter=".*",Int_t size=0,Int_t time=0)
    {
	// adds all root members match the filter of all zip files matching the expression
	// to TChain (has to be created before). The file list should contain
        // one filename perline.
	if(chain == 0){
	    printf("Error: makeChainList() : TChain pointer is NULL!");
	    return kFALSE;
	}

	if(gSystem->AccessPathName(listfile)){
  	    printf("Error: makeChainList() : list file does not exist!");
	    return kFALSE;
	}

	Char_t line[1000];
	ifstream inp;


	inp.open(listfile.Data());
	TString name;
	while(!inp.eof()){
	    inp.getline (line, 1000);
	    name = line;

	    if(gSystem->AccessPathName(name)){
		printf("Error: makeChainList() : file %s does not exist!",name.Data());
		continue;
	    }

	    HZip::makeChain(name,chain,filter,size,time);
	}
	inp.close();
	return kTRUE;
    }

    static Bool_t addFile(TString zipname,TString membername, Int_t mode=0)
    {
	// mode = 0  ==> do not replace existing members and warn
        // mode = 1  ==> do not replace existing members and do not warn
        // mode = 2  ==> replace existing members and do not warn

	TString zipName = zipname;
	zipName.ReplaceAll(".zip","");
	TString cmd = Form("zip -j -g -n .root %s %s 1>/dev/null",zipName.Data(),membername.Data());

	if(!HZip::exists(membername,kFALSE,kFALSE)) return kFALSE; // complain if not existing
	if(!HZip::exists(zipname,kTRUE))                           // do not complain if not existing
	{ // create zipfile new
	    Int_t rc = gSystem->Exec(cmd.Data());
	    if(rc == 0) {
		cout<<"adding: "<<membername.Data()<<" (new)"<<endl;
		return kTRUE;
	    }
	    else {
		printf("Error: addFile() : zip returned with error!\n");
		return kFALSE;
	    }

	} else { // add to existing zipfile
            Bool_t inside = HZip::isInside(zipname + "#" + membername);
	    if(mode == 2){ // replace
		Int_t rc = gSystem->Exec(cmd.Data());
		if(rc == 0) {
		    if(!inside){
			cout<<"adding: "<<membername.Data()<<" (added)"<<endl;
		    } else {
			cout<<"adding: "<<membername.Data()<<" (replace)"<<endl;
		    }
		    return kTRUE; }
		else {
		    printf("Error: addFile() : zip returned with error!\n");
		    return kFALSE;
		}

	    } else {  // mode 0 + 1
		if(!HZip::isInside(zipname + "#" + membername)){ // add new member
		    Int_t rc = gSystem->Exec(cmd.Data());
		    if(rc == 0) {
			cout<<"adding: "<<membername.Data()<<" (new)"<<endl;
			return kTRUE;
		    }
		    else {
			printf("Error: addFile() : zip returned with error!\n");
			return kFALSE;
		    }
		} else { // exists already
		    if (mode == 0) { // warn + kFALSE
			printf("Error: addFile() : Member = %s already existing inside zipfile %s\n!",membername.Data(),zipname.Data());
                        return kFALSE;
		    } else { // do not warn + kTRUE
                        cout<<"adding: "<<membername.Data()<<" (replace)"<<endl;
			return kTRUE;
		    }
		}
	    }

	}


      return kFALSE;
    }

    static Bool_t addFiles(TString zipname,TList* list, Int_t mode=0)
    {
	// mode = 0  ==> do not replace existing members and warn
        // mode = 1  ==> do not replace existing members and do not warn
        // mode = 2  ==> replace existing members and do not warn
	cout<<"-------------------------------------------------------------------------------"<<endl;
	cout<<"Adding files to file "<<zipname.Data()<<" :"<<endl;

	TObjString* member;
	TIterator* iter = list->MakeIterator();

	while((member = (TObjString*)iter->Next()) != 0){
	    TString membername = member->GetString();
	    if(!addFile(zipname,membername,mode)) {
                delete iter;
		cout<<"-------------------------------------------------------------------------------"<<endl;
		return kFALSE;
	    }
	}
	cout<<"-------------------------------------------------------------------------------"<<endl;
        delete iter;
	return kTRUE;
    }

    static Bool_t test(TString zipname){
        // run unzip test on zipfile
	TString cmd = Form("unzip -t %s",zipname.Data());
	Int_t rc = gSystem->Exec(cmd.Data());
	if(rc == 0) { return kTRUE; }
	else        {
	    printf("Error: test() : zip returned with error!");
	    return kFALSE;
	}
    }

    static Bool_t unzip(TString zipname,TString outDir=""){
        // unzip content of zipfile to outDir (optional, default is local dir)
	TString cmd;
	if(outDir != "")  cmd = Form("unzip %s -d %s",zipname.Data(),outDir.Data());
	else              cmd = Form("unzip %s"      ,zipname.Data());
	Int_t rc = gSystem->Exec(cmd.Data());
	if(rc == 0) { return kTRUE; }
	else        {
	    printf("Error: unzip() : zip returned with error!");
	    return kFALSE;
	}
    }



    ClassDef(HZip,0);
};

//ClassImp(HZip)

#endif

 hzip.h:1
 hzip.h:2
 hzip.h:3
 hzip.h:4
 hzip.h:5
 hzip.h:6
 hzip.h:7
 hzip.h:8
 hzip.h:9
 hzip.h:10
 hzip.h:11
 hzip.h:12
 hzip.h:13
 hzip.h:14
 hzip.h:15
 hzip.h:16
 hzip.h:17
 hzip.h:18
 hzip.h:19
 hzip.h:20
 hzip.h:21
 hzip.h:22
 hzip.h:23
 hzip.h:24
 hzip.h:25
 hzip.h:26
 hzip.h:27
 hzip.h:28
 hzip.h:29
 hzip.h:30
 hzip.h:31
 hzip.h:32
 hzip.h:33
 hzip.h:34
 hzip.h:35
 hzip.h:36
 hzip.h:37
 hzip.h:38
 hzip.h:39
 hzip.h:40
 hzip.h:41
 hzip.h:42
 hzip.h:43
 hzip.h:44
 hzip.h:45
 hzip.h:46
 hzip.h:47
 hzip.h:48
 hzip.h:49
 hzip.h:50
 hzip.h:51
 hzip.h:52
 hzip.h:53
 hzip.h:54
 hzip.h:55
 hzip.h:56
 hzip.h:57
 hzip.h:58
 hzip.h:59
 hzip.h:60
 hzip.h:61
 hzip.h:62
 hzip.h:63
 hzip.h:64
 hzip.h:65
 hzip.h:66
 hzip.h:67
 hzip.h:68
 hzip.h:69
 hzip.h:70
 hzip.h:71
 hzip.h:72
 hzip.h:73
 hzip.h:74
 hzip.h:75
 hzip.h:76
 hzip.h:77
 hzip.h:78
 hzip.h:79
 hzip.h:80
 hzip.h:81
 hzip.h:82
 hzip.h:83
 hzip.h:84
 hzip.h:85
 hzip.h:86
 hzip.h:87
 hzip.h:88
 hzip.h:89
 hzip.h:90
 hzip.h:91
 hzip.h:92
 hzip.h:93
 hzip.h:94
 hzip.h:95
 hzip.h:96
 hzip.h:97
 hzip.h:98
 hzip.h:99
 hzip.h:100
 hzip.h:101
 hzip.h:102
 hzip.h:103
 hzip.h:104
 hzip.h:105
 hzip.h:106
 hzip.h:107
 hzip.h:108
 hzip.h:109
 hzip.h:110
 hzip.h:111
 hzip.h:112
 hzip.h:113
 hzip.h:114
 hzip.h:115
 hzip.h:116
 hzip.h:117
 hzip.h:118
 hzip.h:119
 hzip.h:120
 hzip.h:121
 hzip.h:122
 hzip.h:123
 hzip.h:124
 hzip.h:125
 hzip.h:126
 hzip.h:127
 hzip.h:128
 hzip.h:129
 hzip.h:130
 hzip.h:131
 hzip.h:132
 hzip.h:133
 hzip.h:134
 hzip.h:135
 hzip.h:136
 hzip.h:137
 hzip.h:138
 hzip.h:139
 hzip.h:140
 hzip.h:141
 hzip.h:142
 hzip.h:143
 hzip.h:144
 hzip.h:145
 hzip.h:146
 hzip.h:147
 hzip.h:148
 hzip.h:149
 hzip.h:150
 hzip.h:151
 hzip.h:152
 hzip.h:153
 hzip.h:154
 hzip.h:155
 hzip.h:156
 hzip.h:157
 hzip.h:158
 hzip.h:159
 hzip.h:160
 hzip.h:161
 hzip.h:162
 hzip.h:163
 hzip.h:164
 hzip.h:165
 hzip.h:166
 hzip.h:167
 hzip.h:168
 hzip.h:169
 hzip.h:170
 hzip.h:171
 hzip.h:172
 hzip.h:173
 hzip.h:174
 hzip.h:175
 hzip.h:176
 hzip.h:177
 hzip.h:178
 hzip.h:179
 hzip.h:180
 hzip.h:181
 hzip.h:182
 hzip.h:183
 hzip.h:184
 hzip.h:185
 hzip.h:186
 hzip.h:187
 hzip.h:188
 hzip.h:189
 hzip.h:190
 hzip.h:191
 hzip.h:192
 hzip.h:193
 hzip.h:194
 hzip.h:195
 hzip.h:196
 hzip.h:197
 hzip.h:198
 hzip.h:199
 hzip.h:200
 hzip.h:201
 hzip.h:202
 hzip.h:203
 hzip.h:204
 hzip.h:205
 hzip.h:206
 hzip.h:207
 hzip.h:208
 hzip.h:209
 hzip.h:210
 hzip.h:211
 hzip.h:212
 hzip.h:213
 hzip.h:214
 hzip.h:215
 hzip.h:216
 hzip.h:217
 hzip.h:218
 hzip.h:219
 hzip.h:220
 hzip.h:221
 hzip.h:222
 hzip.h:223
 hzip.h:224
 hzip.h:225
 hzip.h:226
 hzip.h:227
 hzip.h:228
 hzip.h:229
 hzip.h:230
 hzip.h:231
 hzip.h:232
 hzip.h:233
 hzip.h:234
 hzip.h:235
 hzip.h:236
 hzip.h:237
 hzip.h:238
 hzip.h:239
 hzip.h:240
 hzip.h:241
 hzip.h:242
 hzip.h:243
 hzip.h:244
 hzip.h:245
 hzip.h:246
 hzip.h:247
 hzip.h:248
 hzip.h:249
 hzip.h:250
 hzip.h:251
 hzip.h:252
 hzip.h:253
 hzip.h:254
 hzip.h:255
 hzip.h:256
 hzip.h:257
 hzip.h:258
 hzip.h:259
 hzip.h:260
 hzip.h:261
 hzip.h:262
 hzip.h:263
 hzip.h:264
 hzip.h:265
 hzip.h:266
 hzip.h:267
 hzip.h:268
 hzip.h:269
 hzip.h:270
 hzip.h:271
 hzip.h:272
 hzip.h:273
 hzip.h:274
 hzip.h:275
 hzip.h:276
 hzip.h:277
 hzip.h:278
 hzip.h:279
 hzip.h:280
 hzip.h:281
 hzip.h:282
 hzip.h:283
 hzip.h:284
 hzip.h:285
 hzip.h:286
 hzip.h:287
 hzip.h:288
 hzip.h:289
 hzip.h:290
 hzip.h:291
 hzip.h:292
 hzip.h:293
 hzip.h:294
 hzip.h:295
 hzip.h:296
 hzip.h:297
 hzip.h:298
 hzip.h:299
 hzip.h:300
 hzip.h:301
 hzip.h:302
 hzip.h:303
 hzip.h:304
 hzip.h:305
 hzip.h:306
 hzip.h:307
 hzip.h:308
 hzip.h:309
 hzip.h:310
 hzip.h:311
 hzip.h:312
 hzip.h:313
 hzip.h:314
 hzip.h:315
 hzip.h:316
 hzip.h:317
 hzip.h:318
 hzip.h:319
 hzip.h:320
 hzip.h:321
 hzip.h:322
 hzip.h:323
 hzip.h:324
 hzip.h:325
 hzip.h:326
 hzip.h:327
 hzip.h:328
 hzip.h:329
 hzip.h:330
 hzip.h:331
 hzip.h:332
 hzip.h:333
 hzip.h:334
 hzip.h:335
 hzip.h:336
 hzip.h:337
 hzip.h:338
 hzip.h:339
 hzip.h:340
 hzip.h:341
 hzip.h:342
 hzip.h:343
 hzip.h:344
 hzip.h:345
 hzip.h:346
 hzip.h:347
 hzip.h:348
 hzip.h:349
 hzip.h:350
 hzip.h:351
 hzip.h:352
 hzip.h:353
 hzip.h:354
 hzip.h:355
 hzip.h:356
 hzip.h:357
 hzip.h:358
 hzip.h:359
 hzip.h:360
 hzip.h:361
 hzip.h:362
 hzip.h:363
 hzip.h:364
 hzip.h:365
 hzip.h:366
 hzip.h:367
 hzip.h:368
 hzip.h:369
 hzip.h:370
 hzip.h:371
 hzip.h:372
 hzip.h:373
 hzip.h:374
 hzip.h:375
 hzip.h:376
 hzip.h:377
 hzip.h:378
 hzip.h:379
 hzip.h:380
 hzip.h:381
 hzip.h:382
 hzip.h:383
 hzip.h:384
 hzip.h:385
 hzip.h:386
 hzip.h:387
 hzip.h:388
 hzip.h:389
 hzip.h:390
 hzip.h:391
 hzip.h:392
 hzip.h:393
 hzip.h:394
 hzip.h:395
 hzip.h:396
 hzip.h:397
 hzip.h:398
 hzip.h:399
 hzip.h:400
 hzip.h:401
 hzip.h:402
 hzip.h:403
 hzip.h:404
 hzip.h:405
 hzip.h:406
 hzip.h:407
 hzip.h:408
 hzip.h:409
 hzip.h:410
 hzip.h:411
 hzip.h:412
 hzip.h:413
 hzip.h:414
 hzip.h:415
 hzip.h:416
 hzip.h:417
 hzip.h:418
 hzip.h:419
 hzip.h:420
 hzip.h:421
 hzip.h:422
 hzip.h:423
 hzip.h:424
 hzip.h:425
 hzip.h:426
 hzip.h:427
 hzip.h:428
 hzip.h:429
 hzip.h:430
 hzip.h:431
 hzip.h:432
 hzip.h:433
 hzip.h:434
 hzip.h:435
 hzip.h:436
 hzip.h:437
 hzip.h:438
 hzip.h:439
 hzip.h:440
 hzip.h:441
 hzip.h:442
 hzip.h:443
 hzip.h:444
 hzip.h:445
 hzip.h:446
 hzip.h:447
 hzip.h:448
 hzip.h:449
 hzip.h:450
 hzip.h:451
 hzip.h:452
 hzip.h:453
 hzip.h:454
 hzip.h:455
 hzip.h:456
 hzip.h:457
 hzip.h:458
 hzip.h:459
 hzip.h:460
 hzip.h:461
 hzip.h:462
 hzip.h:463
 hzip.h:464
 hzip.h:465
 hzip.h:466
 hzip.h:467
 hzip.h:468
 hzip.h:469
 hzip.h:470
 hzip.h:471
 hzip.h:472
 hzip.h:473
 hzip.h:474
 hzip.h:475
 hzip.h:476
 hzip.h:477
 hzip.h:478
 hzip.h:479
 hzip.h:480
 hzip.h:481
 hzip.h:482
 hzip.h:483
 hzip.h:484
 hzip.h:485
 hzip.h:486
 hzip.h:487
 hzip.h:488
 hzip.h:489
 hzip.h:490
 hzip.h:491
 hzip.h:492
 hzip.h:493
 hzip.h:494
 hzip.h:495
 hzip.h:496
 hzip.h:497
 hzip.h:498
 hzip.h:499
 hzip.h:500
 hzip.h:501
 hzip.h:502
 hzip.h:503
 hzip.h:504
 hzip.h:505
 hzip.h:506
 hzip.h:507
 hzip.h:508
 hzip.h:509
 hzip.h:510
 hzip.h:511
 hzip.h:512
 hzip.h:513
 hzip.h:514
 hzip.h:515
 hzip.h:516
 hzip.h:517
 hzip.h:518
 hzip.h:519
 hzip.h:520
 hzip.h:521
 hzip.h:522
 hzip.h:523
 hzip.h:524
 hzip.h:525
 hzip.h:526
 hzip.h:527