MSV FM

Path : /hermes/bosweb/b1536/houndchow.com/tmp/a/d/c/

File Upload :

Current < : /hermes/bosweb/b1536/houndchow.com/tmp/a/d/c/adc2f2c719980a017d15fe3ba64128fe

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