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