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