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