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