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b0k64v