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