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