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