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