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