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