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