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