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