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