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