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