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