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