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