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