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