From 2785b6e766714020fa2e7932167b5ca574771541 Mon Sep 17 00:00:00 2001
From: fumiama <s862105088@gmail.com>
Date: Thu, 8 Apr 2021 00:27:29 +0800
Subject: [PATCH] =?UTF-8?q?=E5=88=9D=E6=AD=A5=E5=AE=8C=E5=96=8464?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 64/base1464le      | Bin 12704 -> 0 bytes
 64/base1464le.c    |  89 +++++++++++++++++--
 64/base1464le.h    |   1 +
 64/base1464le.txt  | Bin 0 -> 7826 bytes
 64/base1464leo.txt | 213 +++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 295 insertions(+), 8 deletions(-)
 delete mode 100755 64/base1464le
 create mode 100644 64/base1464le.txt
 create mode 100644 64/base1464leo.txt

diff --git a/64/base1464le b/64/base1464le
deleted file mode 100755
index 9c41c1165c4b30f34628c08142a53fc810da4a21..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 12704
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

diff --git a/64/base1464le.c b/64/base1464le.c
index f9e333a..f59dbf0 100644
--- a/64/base1464le.c
+++ b/64/base1464le.c
@@ -4,7 +4,7 @@
 #include <stdlib.h>
 #include "base1464le.h"
 
-#define DEBUG
+//#define DEBUG
 
 LENDAT* encode(const char* data, const u_int64_t len) {
 	LENDAT* encd = (LENDAT*)malloc(sizeof(LENDAT));
@@ -28,19 +28,21 @@ LENDAT* encode(const char* data, const u_int64_t len) {
 	uint64_t* vals = (uint64_t*)(encd->data);
 	uint64_t n = 0;
 	uint64_t i = 0;
-	for(; i < len - 7; i *= 7) {
+	for(; i < len - 7; i += 7) {
 		register uint64_t sum = 0x000000000000003f & ((uint64_t)data[i] >> 2);
 		sum |= ((((uint64_t)data[i + 1] >> 2) | (data[i] << 6)) << 8) & 0x000000000000ff00;
 		sum |= ((((uint64_t)data[i + 1] << 4) | ((uint64_t)data[i + 2] >> 4)) << 16) & 0x00000000003f0000;
 		sum |= ((((uint64_t)data[i + 2] << 4) | ((uint64_t)data[i + 3] >> 4)) << 24) & 0x00000000ff000000;
 		sum |= ((((uint64_t)data[i + 3] << 2) | ((uint64_t)data[i + 4] >> 6)) << 32) & 0x0000003f00000000;
 		sum |= ((((uint64_t)data[i + 4] << 2) | ((uint64_t)data[i + 5] >> 6)) << 40) & 0x0000ff0000000000;
-		sum |= (((uint64_t)data[i + 5] << 2) << 48) & 0x003f000000000000;
+		sum |= ((uint64_t)data[i + 5] << 48) & 0x003f000000000000;
 		sum |= ((uint64_t)data[i + 6] << 56) & 0xff00000000000000;
 		sum += 0x004e004e004e004e;
 		vals[n++] = sum;
+		#ifdef DEBUG
+			printf("i: %llu, add sum: %016llx\n", i, sum);
+		#endif
 	}
-	i /= 7;
 	if(offset > 0) {
 		register uint64_t sum = 0x000000000000003f & (data[i] >> 2);
 		sum |= (((uint64_t)data[i] << 6) << 8) & 0x000000000000c000;
@@ -58,7 +60,7 @@ LENDAT* encode(const char* data, const u_int64_t len) {
 						sum |= (((uint64_t)data[i + 4] << 2) << 40) & 0x0000fc0000000000;
 						if(offset > 5) {
 							sum |= (((uint64_t)data[i + 5] >> 6) << 40) & 0x0000030000000000;
-							sum |= (((uint64_t)data[i + 5] << 2) << 48) & 0x003f000000000000;
+							sum |= ((uint64_t)data[i + 5] << 48) & 0x003f000000000000;
 						}
 					}
 				}
@@ -66,6 +68,9 @@ LENDAT* encode(const char* data, const u_int64_t len) {
 		}
 		sum += 0x004e004e004e004e;
 		vals[n] = sum;
+		#ifdef DEBUG
+			printf("i: %llu, add sum: %016llx\n", i, sum);
+		#endif
 		encd->data[outlen - 2] = '=';
 		encd->data[outlen - 1] = offset;
 	}
@@ -132,9 +137,77 @@ LENDAT* decode(const char* data, const u_int64_t len) {
 	return decd;
 }
 
-int main() {
-	LENDAT* ld = encode("simple test addafiaofhiowq cfaiohfoiqwnfioqw", 45);
-	puts(ld->data);
+void encode_file(const char* input, const char* output) {
+	FILE* fp = NULL;
+	fp = fopen(input, "rb");
+	if(fp) {
+		FILE* fpo = NULL;
+		fpo = fopen(output, "wb");
+		if(fpo) {
+			char* bufi = (char*)malloc(B14BUFSIZ/7*7);
+			if(bufi) {
+				int cnt = 0;
+				fputc(0xFE, fpo);
+    			fputc(0xFF, fpo);
+				while((cnt = fread(bufi, 1, B14BUFSIZ/7*7, fp))) {
+					LENDAT* ld = encode(bufi, cnt);
+					if(fwrite(ld->data, ld->len, 1, fpo) <= 0) {
+						puts("Write file error!");
+						exit(EXIT_FAILURE);
+					}
+					free(ld);
+				}
+				free(bufi);
+			} else puts("Allocate input buffer error!");
+			fclose(fpo);
+		} else puts("Open output file error!");
+		fclose(fp);
+	} else puts("Open input file error!");
+}
+
+int rm_head(FILE* fp) {
+	int ch = fgetc(fp);
+	if(ch == 0xFE) fgetc(fp);
+	else rewind(fp);
+}
+
+void decode_file(const char* input, const char* output) {
+	FILE* fp = NULL;
+	fp = fopen(input, "rb");
+	if(fp) {
+		FILE* fpo = NULL;
+		fpo = fopen(output, "wb");
+		if(fpo) {
+			char* bufi = (char*)malloc(B14BUFSIZ/8*8);
+			if(bufi) {
+				int cnt = 0;
+				rm_head(fp);
+				while((cnt = fread(bufi, 1, B14BUFSIZ/7*7, fp))) {
+					LENDAT* ld = decode(bufi, cnt);
+					if(fwrite(ld->data, ld->len, 1, fpo) <= 0) {
+						puts("Write file error!");
+						exit(EXIT_FAILURE);
+					}
+					free(ld);
+				}
+				free(bufi);
+			} else puts("Allocate input buffer error!");
+			fclose(fpo);
+		} else puts("Open output file error!");
+		fclose(fp);
+	} else puts("Open input file error!");
+}
+
+#define B1464LE_TEST
+#ifdef B1464LE_TEST
+int main(int argc, char** argv) {
+	LENDAT* ld = encode("just a simple test from fumiama", 32);
+	//puts(ld->data);
 	LENDAT* le = decode(ld->data, ld->len);
 	puts(le->data);
+	if(argc == 4) {
+		encode_file(argv[1], argv[2]);
+		decode_file(argv[2], argv[3]);
+	}
 }
+#endif
diff --git a/64/base1464le.h b/64/base1464le.h
index f864930..76d4a49 100644
--- a/64/base1464le.h
+++ b/64/base1464le.h
@@ -1,5 +1,6 @@
 #include <stdint.h>
 
+#define B14BUFSIZ 16384
 struct LENDAT {
     uint8_t* data;
     uint64_t len;
diff --git a/64/base1464le.txt b/64/base1464le.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f868d82baa08e545ba259469cda1edd14590f01e
GIT binary patch
literal 7826
zcmd^EZEzF!nZL1Guze;e%}@}KR!1-~DY^3Eb9&d3xhlbRNGh%D^-9*-lC53sdM$e;
zYgZB&Tb5)=7M6VnK3m2K%$W>a^Px8fdFh0?G6R%SNaNPH#|<PfL%9T)xqQfE7+!KS
z<eq0=WXU*(`}sa;wDW&`p5OC(e$VrN_*K*Ik{cSPrCsz0ano7V_XGYA`=3&3Pa9Ry
zZJ^FZtDVcDZ_-D58R2QR))O0&d`2=ibRzsBkxAwTM|wiMvDMH&onVF4?7G3J;d1ID
z_9lINfaU9m4fa&r>-?FGaUYldy1i7K3jeC_8Q#cp(h14rUhb)6);h}DmU}*Nf7A0E
zWrTSrgI>p~<lVvPgo*ozTuHqpvRn)K?P$E)FC0vnt(Uq4;Sj9XmoN!N_C_$ix14CG
zCkK~XNk@jH21kOXmO3KYzoPkNS0nMJ^q#*{Sd-l9pN{nKbkgJB(qM6ai!ld}z`PbV
zH#n25_Ff~FWG^K;c{*T7#CyC#hWNsAReX+m!gefNIe`16vNNKepA6M7Gvan?4N0YA
zl8OF(bV`~|3BFayg#V<>bzJe9;XGwczZ?E?_^aUifd}dPBM(FWK6pF*aQLD3)7_uq
zcWEU2VDQV4hwVw{gUo}GhmHi1aOG&Q6IEe*)4Dh2<(%<j;q`WgYfjc%&Sp%)HE(VI
zc(2LvhgO5@GttvA$$qEjGe;TWNUo&E#I4N<ai28em-sr{ws5>J<WtVKdpotP`|U^8
zo5_?DX0`_WZK5p!{oW-#cf=nypC_NSkNbViXY%VYMe9|x8G7P@An#z`>8Y}pp&uJA
z^~lYc{Je=omHnCaCb^b5AinG-B(ej>b*z<hgBRs0>W!2ga3D5k2&(`1z$R)<lH;c(
zm`~U}$HXp<CeLMuGbTGt{+8+PUDs4f-eWF;KeFJTNm=4sh%?rc12X#E@(b~Y4oh?@
zI3kJsYPL08DT&+_;*W#-{W4c)o3$L){kChP;9$@7pX{#6+wr_D5&X>lgQf>*uzz-P
z@MiiY|5u^0T@Utxzgqq+bA2!PtNvE+C&T|U{8i|6|Cbr~F64*=i}-rJ<qh<IR`<(~
zh=iAtP9$pRl__&Lo@^7=#teyAIMhyuUg9ox$&R7cG;^YxZL-R>4Hx|z!M+pB(O#Jz
zX}IT#_X1vR2C!#-Jhi$N=0{;&mdl<G{|Ns_Rb0+muI@Fp*Aed|VyTVPcj5k(F)#m-
z_XYQO%;a;jw_KMKZeMBR3(UKK(~8Cc%c<yQXNAq6|I!D<4OBTXnBV_su+6uM`K2U_
zFScZC>w<`@<`k8P4{e8W2~o8p#@j}ImAAH`D`Ik-x2;IThF_#A0;AT?#VYN43-zS!
zjOB7<qw;$_VzOs!OU0u7Nsc>(_i|0pm-d*to@^}vMySf4yPQS)&~U%EEx+-ZTAm~f
zt|MaaLgx*}cAK0Nt%me{vD&c{?DM&}g&t}x;bPHU#rIY2kMSh==+>ptJ7Se%f&1(0
z!8+BBy2dk>sRI8skt^LPL7>WG23oZf@Q3*0mQvd@aJ~(NcD7E+n!SNv%wF_EFYr+U
z?wR+mqj)`BXI(HpWO9@@=5Zt;j;Z7*;Jn&fXZx>oEV<E9XZv+D7T@ZqBRrPVX>Ff4
zm%r~5h=+JcsB8Q+;1BNkwd=t;v5nOCh?1}IZ=>ShWr5LPZ0N_-GFwS7CYzk!RdB@d
z!*h7D6yxO)T%lcQyW*ef=JLFMY5)g?xGeV1(|KObxl@TY_M_I4o>)@F*MB58Qe^>y
z^-uELy)}F*yfr=0MU}^A75gkB8!V?1Ua(KC=Tx+sN4}`U_#F6U`WL%lz1F3GL&W1K
zeN<-orocDcD~Lun@L#Yp8ie?*<)#8cp08H1wXQhW*Agi4oa(O;)-<O2-w$kp_&j5U
zeHA`h-|ZD9$sAW@?}PZwafkaj{$SGXiVd5b<*iGRH-W#y(saVxk(u)k&WH0Dtk;X|
z0&yGX;Jzh(6%XTD-2IcX&NX({`gs;`vtT?Ut~`qWo*+go2gJ>t1v~(Jz#wjLo%W_c
zTH{wkI@Yi9N>RMbowER!TU1;Ejxg>QjCULQ8ST4I!ux#>c=_@1j^}=gn-^Db-fb$*
zF|J%W=|EV|$0`pY4$VcpvS7T~_4q|xSG0kB^0?OVsN!nz>*0CLik&OE;kRhLC3&2y
z>&-iNY}BfLf4qIBfe-&NfP9GiJ;FPd(}ld_0{j;6z=H7<SL5k?MB!N{{1);xJ)Fm(
z;=kZ}yTA{TclpV<*H>!0VVQ}TIx$Yx+l%sr|58NsE$iNqor$1sTe0Ve_<d?w!>r~0
zunG7Xd3u|3K2Lv`=M&_CMfuS!D|T475I=Eq>lqY&GNU~roI}$a)RO^&=ZLrmak;qj
zGll1`hBz+BGjSa^_^Y44(4Pz9kWtV7l9<PN0go$js^A>Y2Rx#jQ~j;XBK}clm35gx
zr!A8224&C#Yay>A-s+M$e!s*~%j-#dW23U3^#b_K7)aQUsQL@^SQ~F7kRSh!Dr+;;
zU+L-WTuI)bj)_8(qAwyUZ;tn}?M))^YJvWulB#aY5VMvGfZIAkN*u)dX!>bV$)|o_
z3we%tUwodb0Q=t2^)-xhyQZWIlI&}iZ&=5B8UBgr&l6RS*W3-kmm7#(CeWQV+5J)#
z_i^$TJtH#htGw&Nanv!u!y|oS$2DRp)2HK5L|w1M*<77LQuIEsM|u5O=5OnN!juPc
z1F4=);c{${KAQ0gR|0zdFp7F8uTOM6nz7AVQO9aJt{HTnRnz})kInEM<6Ol*jB9#L
zg8OAn_CK@+m3qa@>Txt{Re2rkuxE=`$xrb}dka}3>Ujfk`f3d8hfjKM4BrPm`t#lg
zs7FU82LF2yzRRC>-yVLT=+p|VFTz7&0`pgQTgR1FgXMNXy`brSXMyfd+!3n_b-zB3
zx{Z9Q)(Otv&(#SqzGk8Eu7dG}bp?zssw?#Mx!Ypi|Db=LvJ}=eX111@^oN9}i|Qf3
zzjr2Fsn<7o{cUOjJ#TqSd;#>CRwrQH7W6K%9zZ>wbB`<f9PtSComQt5>h!n7Fh@6T
z1^*W4)qtW;bQ~;N&#wvSdj1Q`^}QxxDE79B3-1QzPz360?>cLqM@7`FP?xH@Wl+XA
zQgr3>U^mp))%<HVgL^ExnKrf=EEgq=OZ`5op57UIF9G!m=t0z@MS2zTs={CN0W}X$
zn%+izUYHNmapX4mg?!(A!*Vu(cH1ZIml*yp+iq$)?d?6tGoVKnp0DTub^hgusjHMo
z_>sR*&lTyOxKgix-UZzo+pOrSLVtoT?)g`RSH5OG$>4d_`Td}m6+Mr3EZ}Xpx3OE<
z$5{dT2=bHj9|%QPA-}lZ9oF*K?(c)nLEZA`{0eoS{QO};sfQfMvqd@}iFQ--#1W;=
z+UCOk1L7R(NtF);#|Hz*gH?~tx6Pmb4Co`JE-JFKQJx#8`)MZj=lJQ-`5z{<Isx^B
zUUwuF`>J{j?p3bVVa?@jnEzPbku)bBsC8vf)!9&I<mVUH4`>&4{@>6;Fdy@qllAER
z6w7@P{Md-=2KlDs1btBoQgeC+^AqHkMy}y_oE9dO{S`j}@66Y`o1IV(px#})e>Gil
zB`|9Fe8>d4WoZ=Zst(ZIU!$i>f=XT7W>)Ix;(Kh-?op=9e>bbwQ<{EI>J&|{EE*Ro
zey;$IRa|+rI&z^n*Yq>QIp|30l#;*qNk`=>;fl=D;|Y^e|6@N5^wOUd*J>PTyr9>W
zd4Fs7i*C->jjF%5YIrG|=kIO0o#yeJvJUc`hC5xCJ`QjC__=u3_Q!f`L4RIW`3LsV
z{25pMiFPTr7xw!Udx1_{>^U?)<Z-_hbn&C-I4vvnnZ_IHIhJYt892vd^=xd9*8kCP
zrSs3J{CO7{2Zj1p<H_j-cy3y+KQ#ZScm#c$-|zp@v8ZQ*d`qL<{=SHIe5q$6@W3JY
zuC!0|3I~#R-Q!(cJ5AR6ReiUFKI{)dzc)8{dO(IgVNLc#T&7kf(+%f$VPEd2)=R)!
z&>xeG_Sf7y155Z*ke8m4$o|c6o~BR<@GK`>g+AWlh}iM8*Bp%nf?Otm{Eu}G5AlTc
z!5ClZ+yVRW)?XFOH?!)0qkIqaDfSg{zfDwWC`@IPxI+EMb*$0rJGRE3iakfI3Q_zK
z%#Wn<-$AqA=|A4bIKI{Wl)H?n^~^GF4qe^#g4#z=&hacW3H>ze^Fdt%{Rp#lq*um1
zfmYY#c(_0Jfo-YZ*szH*hL#M0y{S^7!~)~_gN=6gaCmd)@}MUgmjl8F3O|++Ey=WW
zT&jXT`z;sf0{);(HS7y}d`<FbG}ga~ns*+sFW6)590mRMbIN>LR`vKHmJ1#e8R3wc
zN3}Yg^IerE++*QRT_?bL=ODkLE<a;A+XMTPUqBrPcm-T(^)U2bLcX=JguNvu_>8Sf
z_@g~u%IJO8elqq~6y^!FPRucXipY-TOj5FS)w=3EzhPc!Q1Ttx3+p5N#rt^<_pq8>
z_3s??Ve0*R2e|f~>Uv#uB-Ianalpe*ol}9I2y4i@bPAfgtJz!NUlRxS<Dt*WH-|Q4
z&->SD>v7!2<UM*!@wcKM=B;DxfPOXhtr2I|$w(((N80Td`hrxQg10jMK=NF6TB_m?
zDt7CGcaYygUq9e$Y1}IAZ3%##mPjYS9;GA)ek<G`>mqocAeP$S>uQI-yxE_}yHcO$
zpf3&YC<N$7nde)`t^UcVqIUtGOna&AkI-k{<=)>qYMl&ueXC+=UdaorYKKX0SUM3@
z&ovj17@z-t;_><}^_@ZOe>^T8C-Qz!?Tq+~w6A8*d8Wb`7w89kKQSw~dzCQM9}~^a
zpVe0~#<o}3Y&;mgit#{<LVp?g2j}POUcrd-p|1HjS?f6*2=T9Dz1u76xK{G$WGV>t
zW4-^lrYn;@@J<HrB3Or(+Ta}xc>ww_ppWMAtZM@BEjdc1i2W$w-6-e!$3$<(LHQn)
z4CLd9X!53|neYzw+suxv(fUf;3TC}W=XbR)0eK1T*VLNs->2$}p!Qvwgm;Raq+&m;
z8{oT%ryFZLaV^fjiS>7KrF%>i1mG=K9PT$M+o`w|?06%!u3qKUebQuir*Jh{4><NK
z_nyDb_9(pH;k(g-@dAAcnGx2cYCMPK0M3{0Kz>=9thWM>c6>mr&z_b<J>L1(!Ec58
z|Fdf<JQDQ6_nV$Lv4vjN{c`_`F49d7{C#*N!hx>zSWEk>=@IBF^m%r8E?NEs;}71S
za+qfzeplKLb#K!06yyW%1|QTx&_^57-z%-h@%<9tG5c74C$S-N3G*8CsgLdn2*%c>
z?s52U1pawf<a{)nYk1EO?_{=Z6#C)S*geIMYe-Fhw;~@E;0NnS9X~z#dlbCG;dppw
zQ}nmuk97aoo)__5rykcu9h-{r+<D{+HLoiD9>5{fCkt?{bi;*EnEjBMjmG^!{+jfT
sT~_lT)YX38$lOK#cHn)l2wT0c5=+$a1GA`;yUd}Pu>Ows7u&z_zZ*G7TL1t6

literal 0
HcmV?d00001

diff --git a/64/base1464leo.txt b/64/base1464leo.txt
new file mode 100644
index 0000000..5a1fbc2
--- /dev/null
+++ b/64/base1464leo.txt
@@ -0,0 +1,213 @@
+//basex64.c
+//fumiama 20210407
+#include <stdio.h>
+#include <stdlib.h>
+#include "base1464le.h"
+
+//#define DEBUG
+
+LENDAT* encode(const char* data, const u_int64_t len) {
+	LENDAT* encd = (LENDAT*)malloc(sizeof(LENDAT));
+	uint64_t outlen = len / 7 * 8;
+	uint8_t offset = len % 7;
+	switch(offset) {	//ﯿ下珏���磏ￗ寗ﯿ卣矯���3篟���
+		case 0: break;
+		case 1: outlen += 4; break;
+		case 2:
+		case 3: outlen += 6; break;
+		case 4:
+		case 5: outlen += 8; break;
+		case 6: outlen += 10; break;
+		default: break;
+	}
+	#ifdef DEBUG
+		printf("outlen: %llu, offset: %u, malloc: %llu\n", outlen, offset, outlen + 8);
+	#endif
+	encd->data = (uint8_t*)malloc(outlen + 8);	//珟���盄8甫翏���냿ￄ结￿皇믏���
+	encd->len = outlen;
+	uint64_t* vals = (uint64_t*)(encd->data);
+	uint64_t n = 0;
+	uint64_t i = 0;
+	for(; i < len - 7; i += 7) {
+		register uint64_t sum = 0x000000000000003f & ((uint64_t)data[i] >> 2);
+		sum |= ((((uint64_t)data[i + 1] >> 2) | (data[i] << 6)) << 8) & 0x000000000000ff00;
+		sum |= ((((uint64_t)data[i + 1] << 4) | ((uint64_t)data[i + 2] >> 4)) << 16) & 0x00000000003f0000;
+		sum |= ((((uint64_t)data[i + 2] << 4) | ((uint64_t)data[i + 3] >> 4)) << 24) & 0x00000000ff000000;
+		sum |= ((((uint64_t)data[i + 3] << 2) | ((uint64_t)data[i + 4] >> 6)) << 32) & 0x0000003f00000000;
+		sum |= ((((uint64_t)data[i + 4] << 2) | ((uint64_t)data[i + 5] >> 6)) << 40) & 0x0000ff0000000000;
+		sum |= ((uint64_t)data[i + 5] << 48) & 0x003f000000000000;
+		sum |= ((uint64_t)data[i + 6] << 56) & 0xff00000000000000;
+		sum += 0x004e004e004e004e;
+		vals[n++] = sum;
+		#ifdef DEBUG
+			printf("i: %llu, add sum: %016llx\n", i, sum);
+		#endif
+	}
+	if(offset > 0) {
+		register uint64_t sum = 0x000000000000003f & (data[i] >> 2);
+		sum |= (((uint64_t)data[i] << 6) << 8) & 0x000000000000c000;
+		if(offset > 1) {
+			sum |= (((uint64_t)data[i + 1] >> 2) << 8) & 0x0000000000003f00;
+			sum |= (((uint64_t)data[i + 1] << 4) << 16) & 0x0000000000300000;
+			if(offset > 2) {
+				sum |= (((uint64_t)data[i + 2] >> 4) << 16) & 0x00000000000f0000;
+				sum |= (((uint64_t)data[i + 2] << 4) << 24) & 0x00000000f0000000;
+				if(offset > 3) {
+					sum |= (((uint64_t)data[i + 3] >> 4) << 24) & 0x000000000f000000;
+					sum |= (((uint64_t)data[i + 3] << 2) << 32) & 0x0000003c00000000;
+					if(offset > 4) {
+						sum |= (((uint64_t)data[i + 4] >> 6) << 32) & 0x0000000300000000;
+						sum |= (((uint64_t)data[i + 4] << 2) << 40) & 0x0000fc0000000000;
+						if(offset > 5) {
+							sum |= (((uint64_t)data[i + 5] >> 6) << 40) & 0x0000030000000000;
+							sum |= ((uint64_t)data[i + 5] << 48) & 0x003f000000000000;
+						}
+					}
+				}
+			}
+		}
+		sum += 0x004e004e004e004e;
+		vals[n] = sum;
+		#ifdef DEBUG
+			printf("i: %llu, add sum: %016llx\n", i, sum);
+		#endif
+		encd->data[outlen - 2] = '=';
+		encd->data[outlen - 1] = offset;
+	}
+	return encd;
+}
+
+LENDAT* decode(const char* data, const u_int64_t len) {
+	LENDAT* decd = (LENDAT*)malloc(sizeof(LENDAT));
+	uint64_t outlen = len;
+	uint8_t offset = 0;
+	if(data[len-2] == '=') {
+		offset = data[len-1];
+		switch(offset) {	//ￗ介移篏���篟￦口的3ﯿ节
+			case 0: break;
+			case 1: outlen -= 4; break;
+			case 2:
+			case 3: outlen -= 6; break;
+			case 4:
+			case 5: outlen -= 8; break;
+			case 6: outlen -= 10; break;
+			default: break;
+		}
+	}
+	outlen = outlen / 8 * 7 + offset;
+	decd->data = (uint8_t*)malloc(outlen);
+	decd->len = outlen;
+	uint64_t* vals = (uint64_t*)data;
+	uint64_t n = 0;
+	uint64_t i = 0;
+	for(; n < len / 8; n++) {
+		register uint64_t sum = vals[n];
+		sum -= 0x004e004e004e004e;
+		decd->data[i++] = ((sum & 0x000000000000003f) << 2) | ((sum & 0x000000000000c000) >> 14);
+		decd->data[i++] = ((sum & 0x0000000000003f00) >> 6) | ((sum & 0x0000000000300000) >> 20);
+		decd->data[i++] = ((sum & 0x00000000000f0000) >> 12) | ((sum & 0x00000000f0000000) >> 28);
+		decd->data[i++] = ((sum & 0x000000000f000000) >> 20) | ((sum & 0x0000003c00000000) >> 34);
+		decd->data[i++] = ((sum & 0x0000000300000000) >> 26) | ((sum & 0x0000fc0000000000) >> 42);
+		decd->data[i++] = ((sum & 0x0000030000000000) >> 34) | ((sum & 0x003f000000000000) >> 48);
+		decd->data[i++] = ((sum & 0xff00000000000000) >> 56);
+	}
+	if(offset > 0) {
+		register uint64_t sum = vals[n];
+		sum -= 0x000000000000004e;
+		decd->data[i++] = ((sum & 0x000000000000003f) << 2) | ((sum & 0x000000000000c000) >> 14);
+		if(offset > 1) {
+			sum -= 0x00000000004e0000;
+			decd->data[i++] = ((sum & 0x0000000000003f00) >> 6) | ((sum & 0x0000000000300000) >> 20);
+			if(offset > 2) {
+				decd->data[i++] = ((sum & 0x00000000000f0000) >> 12) | ((sum & 0x00000000f0000000) >> 28);
+				if(offset > 3) {
+					sum -= 0x0000004e00000000;
+					decd->data[i++] = ((sum & 0x000000000f000000) >> 20) | ((sum & 0x0000003c00000000) >> 34);
+					if(offset > 4) {
+						decd->data[i++] = ((sum & 0x0000000300000000) >> 26) | ((sum & 0x0000fc0000000000) >> 42);
+						if(offset > 5) {
+							sum -= 0x004e000000000000;
+							decd->data[i++] = ((sum & 0x0000030000000000) >> 34) | ((sum & 0x003f000000000000) >> 48);
+						}
+					}
+				}
+			}
+		}
+	}
+	return decd;
+}
+
+void encode_file(const char* input, const char* output) {
+	FILE* fp = NULL;
+	fp = fopen(input, "rb");
+	if(fp) {
+		FILE* fpo = NULL;
+		fpo = fopen(output, "wb");
+		if(fpo) {
+			char* bufi = (char*)malloc(B14BUFSIZ/7*7);
+			if(bufi) {
+				int cnt = 0;
+				fputc(0xFE, fpo);
+    			fputc(0xFF, fpo);
+				while((cnt = fread(bufi, 1, B14BUFSIZ/7*7, fp))) {
+					LENDAT* ld = encode(bufi, cnt);
+					if(fwrite(ld->data, ld->len, 1, fpo) <= 0) {
+						puts("Write file error!");
+						exit(EXIT_FAILURE);
+					}
+					free(ld);
+				}
+				free(bufi);
+			} else puts("Allocate input buffer error!");
+			fclose(fpo);
+		} else puts("Open output file error!");
+		fclose(fp);
+	} else puts("Open input file error!");
+}
+
+int rm_head(FILE* fp) {
+	int ch = fgetc(fp);
+	if(ch == 0xFE) fgetc(fp);
+	else rewind(fp);
+}
+
+void decode_file(const char* input, const char* output) {
+	FILE* fp = NULL;
+	fp = fopen(input, "rb");
+	if(fp) {
+		FILE* fpo = NULL;
+		fpo = fopen(output, "wb");
+		if(fpo) {
+			char* bufi = (char*)malloc(B14BUFSIZ/8*8);
+			if(bufi) {
+				int cnt = 0;
+				rm_head(fp);
+				while((cnt = fread(bufi, 1, B14BUFSIZ/7*7, fp))) {
+					LENDAT* ld = decode(bufi, cnt);
+					if(fwrite(ld->data, ld->len, 1, fpo) <= 0) {
+						puts("Write file error!");
+						exit(EXIT_FAILURE);
+					}
+					free(ld);
+				}
+				free(bufi);
+			} else puts("Allocate input buffer error!");
+			fclose(fpo);
+		} else puts("Open output file error!");
+		fclose(fp);
+	} else puts("Open input file error!");
+}
+
+#define B1464LE_TEST
+#ifdef B1464LE_TEST
+int main(int argc, char** argv) {
+	LENDAT* ld = encode("just a simple test from fumiama", 32);
+	//puts(ld->data);
+	LENDAT* le = decode(ld->data, ld->len);
+	puts(le->data);
+	if(argc == 4) {
+		encode_file(argv[1], argv[2]);
+		decode_file(argv[2], argv[3]);
+	}
+}
+#endif