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