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