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