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