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