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