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