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