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