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https://stage.cloudsds.com/wp-content/uploads/2025/08/Role-of-HMIS-in-Different-Warehousing-and-Logistics-.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PGgzIGlkPSJzdG9yYWdlLXNlZ3JlZ2F0aW9uIj4zLiBNYXhpbWl6aW5nIFN0b3JhZ2UgYW5kIFNlZ3JlZ2F0aW9uPC9oMz4KCjxwPgpTdWNjZXNzZnVsIHdhcmVob3VzaW5nIGludm9sdmVzIGNhcmVmdWwgcGxhbm5pbmcgb2YgbGF5b3V0IHRvIGF2b2lkIGNoZW1pY2FsIGluY29tcGF0aWJpbGl0aWVzIGFuZCBmaXJlIGhhemFyZHMuIApITUlTIHJhdGluZ3MgZ3VpZGU6CjwvcD4KCjx1bD4KICA8bGk+PHN0cm9uZz5TZWdyZWdhdGlvbiBwcmFjdGljZXM6PC9zdHJvbmc+IEZsYW1tYWJsZXMgd2l0aCBoaWdoIGZsYW1tYWJpbGl0eSByYXRpbmdzIChITUlTIG9yYW5nZSByYXRpbmdzIDPigJM0KSBhcmUga2VwdCBpbiBleHBsb3Npb24tcHJvb2YgY2FiaW5ldHMgb3Igc3BlY2lhbGx5IGRlc2lnbmF0ZWQgZmxhbW1hYmxlIGxpcXVpZCBzdG9yYWdlIHJvb21zLiBPeGlkaXplcnMgYW5kIGNvcnJvc2l2ZXPigJRtYXJrZWQgYnkgdGhlaXIgb3JhbmdlIHBoeXNpY2FsIGhhemFyZCByYXRpbmfigJRhcmUgc2VwYXJhdGVkIHRvIGF2b2lkIHZpb2xlbnQgcmVhY3Rpb25zLjwvbGk+CiAgPGxpPjxzdHJvbmc+U2hlbGYgYXJyYW5nZW1lbnQ6PC9zdHJvbmc+IEhNSVMtY29kZWQgbG9jYXRpb25zIG9mIGJpbnMgYWxsb3cgaXRlbXMgbmVlZGluZyB0aGUgc2FtZSBQUEUgYW5kIGhhbmRsaW5nIGNvbmRpdGlvbnMgdG8gYmUgc3RvcmVkIHRvZ2V0aGVyLCBtYWtpbmcgcGljay1hbmQtcGFjayBvcGVyYXRpb25zIGVhc2llci48L2xpPgogIDxsaT48c3Ryb25nPlN0b2NrIG1hbmFnZW1lbnQ6PC9zdHJvbmc+IFdhcmVob3VzZSBNYW5hZ2VtZW50IFN5c3RlbXMgKFdNUykgaW50ZWdyYXRlZCB3aXRoIEhNSVMgaW5mb3JtYXRpb24gYXV0b21hdGljYWxseSBpZGVudGlmeSByZXN0b2NraW5nIG9yIHJlcGxlbmlzaG1lbnQgb2YgaGF6YXJkb3VzIG1hdGVyaWFscywgaW5pdGlhdGluZyBzYWZldHkgZXhhbWluYXRpb24gYmVmb3JlIGFjY2VwdGFuY2UuPC9saT4KPC91bD4KCjxwPgpUaHJvdWdoIGluY29ycG9yYXRpb24gb2YgSE1JUyBzbWFydHMgaW50byBXTVMgYWxnb3JpdGhtcywgYnVzaW5lc3NlcyBhdHRhaW4gZHluYW1pYyBzdG9yYWdlIG9wdGltaXphdGlvbiwgCnJlZHVjaW5nIGJvdGggcmlzayBhbmQgZm9vdHByaW50Lgo8L3A+Cg==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PGgzIGlkPSJ0ZWNobm9sb2d5LWF1dG9tYXRpb24iPjcuIFVzaW5nIFRlY2hub2xvZ3kgYW5kIEF1dG9tYXRpb248L2gzPgoKPHA+ClRoZSBXYXJlaG91c2Ugb2YgdGhlIEZ1dHVyZSBpcyBjaGFyYWN0ZXJpemVkIGJ5IHJvYm90aWNzLCBhdXRvbWF0aW9uLCBhbmQgZGF0YS1kcml2ZW4gZGVjaXNpb24tbWFraW5nLiBITUlTIGVuaGFuY2VzIHN1Y2ggdGVjaG5vbG9naWVzIGJ5Ogo8L3A+Cgo8dWw+CiAgPGxpPjxzdHJvbmc+QXV0b21hdGVkIGxhYmVsaW5nIHByaW50ZXJzOjwvc3Ryb25nPiBJbnRlZ3JhdGVkIHdpdGggSW52ZW50b3J5IENvbnRyb2wgU3lzdGVtcywgdGhlc2UgcHJpbnRlcnMgcHV0IG9uIEhNSVMtY29tcGxpYW50IGxhYmVscyBpbiByZWFsIHRpbWUsIHN1cHBvcnRpbmcganVzdC1pbi10aW1lIHN0b2NraW5nIG9mIG5ldyBwcm9kdWN0IGxpbmVzLjwvbGk+CiAgPGxpPjxzdHJvbmc+Um9ib3RpY3MgZm9yIG1hdGVyaWFsIGhhbmRsaW5nOjwvc3Ryb25nPiBBdXRvbWF0ZWQgR3VpZGVkIFZlaGljbGVzIChBR1ZzKSB3aXRoIEhNSVMgc2Nhbm5lcnMgY2hlY2sgY29udGFpbmVyIGxhYmVscyBhbmQgaGF6YXJkIHByb2ZpbGVzIHByaW9yIHRvIG1hdGVyaWFsIHBpY2t1cCwgYWRqdXN0aW5nIHNwZWVkIGFuZCBwYXRoIGR5bmFtaWNhbGx5IHRvIHN0ZWVyIGNsZWFyIG9mIHNlbnNpdGl2ZSBhcmVhcy48L2xpPgogIDxsaT48c3Ryb25nPkF1Z21lbnRlZCByZWFsaXR5IChBUikgYXNzaXN0YW5jZTo8L3N0cm9uZz4gQVIgaGVhZHNldHMgc3VwZXJpbXBvc2UgSE1JUyBoYXphcmQgZGF0YSBvbnRvIHRoZSB3ZWFyZXIncyB2aXNpb24gYXMgdGhleSBtb3ZlIHRocm91Z2ggdGhlIHdhcmVob3VzZSwgb3B0aW1pemluZyBvcmRlciBwaWNraW5nIGFuZCBzYWZldHkgaW5zcGVjdGlvbnMuPC9saT4KPC91bD4KCjxwPgpBcyBJbnRlcm5ldCBvZiBUaGluZ3MgKElvVCkgc2Vuc29ycyBtb25pdG9yIGVudmlyb25tZW50YWwgY29uZGl0aW9uc+KAlHRlbXBlcmF0dXJlLCBodW1pZGl0eSwgZ2FzIGRldGVjdGlvbuKAlEhNSVMgcmF0aW5ncyBpc3N1ZSBhdXRvbWF0aWMgd2FybmluZ3Mgd2hlbiBjb25kaXRpb25zIHBvc2UgYSB0aHJlYXQgdG8gZXhhY2VyYmF0ZSBjaGVtaWNhbCBoYXphcmRzLCBmb3IgZXhhbXBsZSwgb3ZlcmhlYXRlZCBmbGFtbWFibGUgbGlxdWlkcy4KPC9wPgo=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
