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