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