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