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