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