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